prism 0.17.1 → 0.18.0

data/lib/prism/dsl.rb

@@ -152,6 +152,11 @@ module Prism
       CapturePatternNode.new(value, target, operator_loc, location)
     end
 
+    # Create a new CaseMatchNode node
+    def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = Location())
+      CaseMatchNode.new(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location)
+    end
+
     # Create a new CaseNode node
     def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = Location())
       CaseNode.new(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location)
@@ -363,8 +368,8 @@ module Prism
     end
 
     # Create a new IfNode node
-    def IfNode(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location = Location())
-      IfNode.new(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
+    def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location = Location())
+      IfNode.new(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location)
     end
 
     # Create a new ImaginaryNode node
@@ -518,8 +523,8 @@ module Prism
     end
 
     # Create a new MatchWriteNode node
-    def MatchWriteNode(call, locals, location = Location())
-      MatchWriteNode.new(call, locals, location)
+    def MatchWriteNode(call, targets, location = Location())
+      MatchWriteNode.new(call, targets, location)
     end
 
     # Create a new MissingNode node
@@ -702,11 +707,6 @@ module Prism
       StatementsNode.new(body, location)
     end
 
-    # Create a new StringConcatNode node
-    def StringConcatNode(left, right, location = Location())
-      StringConcatNode.new(left, right, location)
-    end
-
     # Create a new StringNode node
     def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())
       StringNode.new(flags, opening_loc, content_loc, closing_loc, unescaped, location)
@@ -733,8 +733,8 @@ module Prism
     end
 
     # Create a new UnlessNode node
-    def UnlessNode(keyword_loc, predicate, statements, consequent, end_keyword_loc, location = Location())
-      UnlessNode.new(keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
+    def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location = Location())
+      UnlessNode.new(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location)
     end
 
     # Create a new UntilNode node

data/lib/prism/ffi.rb

@@ -14,7 +14,7 @@ module Prism
 
     # Define the library that we will be pulling functions from. Note that this
     # must align with the build shared library from make/rake.
-    ffi_lib File.expand_path("../../build/librubyparser.#{RbConfig::CONFIG["SOEXT"]}", __dir__)
+    ffi_lib File.expand_path("../../build/libprism.#{RbConfig::CONFIG["SOEXT"]}", __dir__)
 
     # Convert a native C type declaration into a symbol that FFI understands.
     # For example:
@@ -230,7 +230,7 @@ module Prism
         loader = Serialize::Loader.new(source, buffer.read)
 
         loader.load_header
-        loader.load_force_encoding
+        loader.load_encoding
         loader.load_start_line
         loader.load_comments
       end
@@ -299,7 +299,7 @@ module Prism
       values << (options.fetch(:frozen_string_literal, false) ? 1 : 0)
 
       template << "C"
-      values << (options[:verbose] ? 0 : 1)
+      values << (options.fetch(:verbose, true) ? 0 : 1)
 
       template << "L"
       if (scopes = options[:scopes])

data/lib/prism/mutation_compiler.rb

@@ -120,6 +120,11 @@ module Prism
       node.copy(value: visit(node.value), target: visit(node.target))
     end
 
+    # Copy a CaseMatchNode node
+    def visit_case_match_node(node)
+      node.copy(predicate: visit(node.predicate), conditions: visit_all(node.conditions), consequent: visit(node.consequent))
+    end
+
     # Copy a CaseNode node
     def visit_case_node(node)
       node.copy(predicate: visit(node.predicate), conditions: visit_all(node.conditions), consequent: visit(node.consequent))
@@ -487,7 +492,7 @@ module Prism
 
     # Copy a MatchWriteNode node
     def visit_match_write_node(node)
-      node.copy(call: visit(node.call))
+      node.copy(call: visit(node.call), targets: visit_all(node.targets))
     end
 
     # Copy a MissingNode node
@@ -670,11 +675,6 @@ module Prism
       node.copy(body: visit_all(node.body))
     end
 
-    # Copy a StringConcatNode node
-    def visit_string_concat_node(node)
-      node.copy(left: visit(node.left), right: visit(node.right))
-    end
-
     # Copy a StringNode node
     def visit_string_node(node)
       node.copy

data/lib/prism/node.rb

@@ -38,6 +38,11 @@ module Prism
       end
       q.current_group.break
     end
+
+    # Convert this node into a graphviz dot graph string.
+    def to_dot
+      DotVisitor.new.tap { |visitor| accept(visitor) }.to_dot
+    end
   end
 
   # Represents the use of the `alias` keyword to alias a global variable.
@@ -2734,6 +2739,142 @@ module Prism
     end
   end
 
+  # Represents the use of a case statement for pattern matching.
+  #
+  #     case true
+  #     in false
+  #     end
+  #     ^^^^^^^^^
+  class CaseMatchNode < Node
+    # attr_reader predicate: Node?
+    attr_reader :predicate
+
+    # attr_reader conditions: Array[Node]
+    attr_reader :conditions
+
+    # attr_reader consequent: ElseNode?
+    attr_reader :consequent
+
+    # attr_reader case_keyword_loc: Location
+    attr_reader :case_keyword_loc
+
+    # attr_reader end_keyword_loc: Location
+    attr_reader :end_keyword_loc
+
+    # def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void
+    def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location)
+      @predicate = predicate
+      @conditions = conditions
+      @consequent = consequent
+      @case_keyword_loc = case_keyword_loc
+      @end_keyword_loc = end_keyword_loc
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_case_match_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [predicate, *conditions, consequent]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      compact = []
+      compact << predicate if predicate
+      compact.concat(conditions)
+      compact << consequent if consequent
+      compact
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [*predicate, *conditions, *consequent, case_keyword_loc, end_keyword_loc]
+    end
+
+    # def copy: (**params) -> CaseMatchNode
+    def copy(**params)
+      CaseMatchNode.new(
+        params.fetch(:predicate) { predicate },
+        params.fetch(:conditions) { conditions },
+        params.fetch(:consequent) { consequent },
+        params.fetch(:case_keyword_loc) { case_keyword_loc },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
+    # def deconstruct: () -> Array[nil | Node]
+    alias deconstruct child_nodes
+
+    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+    def deconstruct_keys(keys)
+      { predicate: predicate, conditions: conditions, consequent: consequent, case_keyword_loc: case_keyword_loc, end_keyword_loc: end_keyword_loc, location: location }
+    end
+
+    # def case_keyword: () -> String
+    def case_keyword
+      case_keyword_loc.slice
+    end
+
+    # def end_keyword: () -> String
+    def end_keyword
+      end_keyword_loc.slice
+    end
+
+    # def inspect(inspector: NodeInspector) -> String
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      if (predicate = self.predicate).nil?
+        inspector << "├── predicate: ∅\n"
+      else
+        inspector << "├── predicate:\n"
+        inspector << predicate.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── conditions: #{inspector.list("#{inspector.prefix}│   ", conditions)}"
+      if (consequent = self.consequent).nil?
+        inspector << "├── consequent: ∅\n"
+      else
+        inspector << "├── consequent:\n"
+        inspector << consequent.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── case_keyword_loc: #{inspector.location(case_keyword_loc)}\n"
+      inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
+      inspector.to_str
+    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
+    def type
+      :case_match_node
+    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
+    def self.type
+      :case_match_node
+    end
+  end
+
   # Represents the use of a case statement.
   #
   #     case true
@@ -7387,6 +7528,9 @@ module Prism
     # attr_reader predicate: Node
     attr_reader :predicate
 
+    # attr_reader then_keyword_loc: Location?
+    attr_reader :then_keyword_loc
+
     # attr_reader statements: StatementsNode?
     attr_reader :statements
 
@@ -7396,10 +7540,11 @@ module Prism
     # attr_reader end_keyword_loc: Location?
     attr_reader :end_keyword_loc
 
-    # def initialize: (if_keyword_loc: Location?, predicate: Node, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
-    def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
+    # def initialize: (if_keyword_loc: Location?, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
+    def initialize(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location)
       @if_keyword_loc = if_keyword_loc
       @predicate = predicate
+      @then_keyword_loc = then_keyword_loc
       @statements = statements
       @consequent = consequent
       @end_keyword_loc = end_keyword_loc
@@ -7431,7 +7576,7 @@ module Prism
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*if_keyword_loc, predicate, *statements, *consequent, *end_keyword_loc]
+      [*if_keyword_loc, predicate, *then_keyword_loc, *statements, *consequent, *end_keyword_loc]
     end
 
     # def copy: (**params) -> IfNode
@@ -7439,6 +7584,7 @@ module Prism
       IfNode.new(
         params.fetch(:if_keyword_loc) { if_keyword_loc },
         params.fetch(:predicate) { predicate },
+        params.fetch(:then_keyword_loc) { then_keyword_loc },
         params.fetch(:statements) { statements },
         params.fetch(:consequent) { consequent },
         params.fetch(:end_keyword_loc) { end_keyword_loc },
@@ -7451,7 +7597,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { if_keyword_loc: if_keyword_loc, predicate: predicate, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
+      { if_keyword_loc: if_keyword_loc, predicate: predicate, then_keyword_loc: then_keyword_loc, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
     end
 
     # def if_keyword: () -> String?
@@ -7459,6 +7605,11 @@ module Prism
       if_keyword_loc&.slice
     end
 
+    # def then_keyword: () -> String?
+    def then_keyword
+      then_keyword_loc&.slice
+    end
+
     # def end_keyword: () -> String?
     def end_keyword
       end_keyword_loc&.slice
@@ -7470,6 +7621,7 @@ module Prism
       inspector << "├── if_keyword_loc: #{inspector.location(if_keyword_loc)}\n"
       inspector << "├── predicate:\n"
       inspector << inspector.child_node(predicate, "│   ")
+      inspector << "├── then_keyword_loc: #{inspector.location(then_keyword_loc)}\n"
       if (statements = self.statements).nil?
         inspector << "├── statements: ∅\n"
       else
@@ -11132,13 +11284,13 @@ module Prism
     # attr_reader call: CallNode
     attr_reader :call
 
-    # attr_reader locals: Array[Symbol]
-    attr_reader :locals
+    # attr_reader targets: Array[Node]
+    attr_reader :targets
 
-    # def initialize: (call: CallNode, locals: Array[Symbol], location: Location) -> void
-    def initialize(call, locals, location)
+    # def initialize: (call: CallNode, targets: Array[Node], location: Location) -> void
+    def initialize(call, targets, location)
       @call = call
-      @locals = locals
+      @targets = targets
       @location = location
     end
 
@@ -11149,24 +11301,24 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [call]
+      [call, *targets]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
-      [call]
+      [call, *targets]
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [call]
+      [call, *targets]
     end
 
     # def copy: (**params) -> MatchWriteNode
     def copy(**params)
       MatchWriteNode.new(
         params.fetch(:call) { call },
-        params.fetch(:locals) { locals },
+        params.fetch(:targets) { targets },
         params.fetch(:location) { location },
       )
     end
@@ -11176,7 +11328,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { call: call, locals: locals, location: location }
+      { call: call, targets: targets, location: location }
     end
 
     # def inspect(inspector: NodeInspector) -> String
@@ -11184,7 +11336,7 @@ module Prism
       inspector << inspector.header(self)
       inspector << "├── call:\n"
       inspector << inspector.child_node(call, "│   ")
-      inspector << "└── locals: #{locals.inspect}\n"
+      inspector << "└── targets: #{inspector.list("#{inspector.prefix}    ", targets)}"
       inspector.to_str
     end
 
@@ -15076,100 +15228,6 @@ module Prism
     end
   end
 
-  # Represents the use of compile-time string concatenation.
-  #
-  #     "foo" "bar"
-  #     ^^^^^^^^^^^
-  class StringConcatNode < Node
-    # attr_reader left: Node
-    attr_reader :left
-
-    # attr_reader right: Node
-    attr_reader :right
-
-    # def initialize: (left: Node, right: Node, location: Location) -> void
-    def initialize(left, right, location)
-      @left = left
-      @right = right
-      @location = location
-    end
-
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_string_concat_node(self)
-    end
-
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [left, right]
-    end
-
-    # def compact_child_nodes: () -> Array[Node]
-    def compact_child_nodes
-      [left, right]
-    end
-
-    # def comment_targets: () -> Array[Node | Location]
-    def comment_targets
-      [left, right]
-    end
-
-    # def copy: (**params) -> StringConcatNode
-    def copy(**params)
-      StringConcatNode.new(
-        params.fetch(:left) { left },
-        params.fetch(:right) { right },
-        params.fetch(:location) { location },
-      )
-    end
-
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { left: left, right: right, location: location }
-    end
-
-    # def inspect(inspector: NodeInspector) -> String
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── left:\n"
-      inspector << inspector.child_node(left, "│   ")
-      inspector << "└── right:\n"
-      inspector << inspector.child_node(right, "    ")
-      inspector.to_str
-    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
-    def type
-      :string_concat_node
-    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
-    def self.type
-      :string_concat_node
-    end
-  end
-
   # Represents a string literal, a string contained within a `%w` list, or
   # plain string content within an interpolated string.
   #
@@ -15762,6 +15820,9 @@ module Prism
     # attr_reader predicate: Node
     attr_reader :predicate
 
+    # attr_reader then_keyword_loc: Location?
+    attr_reader :then_keyword_loc
+
     # attr_reader statements: StatementsNode?
     attr_reader :statements
 
@@ -15771,10 +15832,11 @@ module Prism
     # attr_reader end_keyword_loc: Location?
     attr_reader :end_keyword_loc
 
-    # def initialize: (keyword_loc: Location, predicate: Node, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void
-    def initialize(keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
+    # def initialize: (keyword_loc: Location, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void
+    def initialize(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location)
       @keyword_loc = keyword_loc
       @predicate = predicate
+      @then_keyword_loc = then_keyword_loc
       @statements = statements
       @consequent = consequent
       @end_keyword_loc = end_keyword_loc
@@ -15806,7 +15868,7 @@ module Prism
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [keyword_loc, predicate, *statements, *consequent, *end_keyword_loc]
+      [keyword_loc, predicate, *then_keyword_loc, *statements, *consequent, *end_keyword_loc]
     end
 
     # def copy: (**params) -> UnlessNode
@@ -15814,6 +15876,7 @@ module Prism
       UnlessNode.new(
         params.fetch(:keyword_loc) { keyword_loc },
         params.fetch(:predicate) { predicate },
+        params.fetch(:then_keyword_loc) { then_keyword_loc },
         params.fetch(:statements) { statements },
         params.fetch(:consequent) { consequent },
         params.fetch(:end_keyword_loc) { end_keyword_loc },
@@ -15826,7 +15889,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { keyword_loc: keyword_loc, predicate: predicate, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
+      { keyword_loc: keyword_loc, predicate: predicate, then_keyword_loc: then_keyword_loc, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
     end
 
     # def keyword: () -> String
@@ -15834,6 +15897,11 @@ module Prism
       keyword_loc.slice
     end
 
+    # def then_keyword: () -> String?
+    def then_keyword
+      then_keyword_loc&.slice
+    end
+
     # def end_keyword: () -> String?
     def end_keyword
       end_keyword_loc&.slice
@@ -15845,6 +15913,7 @@ module Prism
       inspector << "├── keyword_loc: #{inspector.location(keyword_loc)}\n"
       inspector << "├── predicate:\n"
       inspector << inspector.child_node(predicate, "│   ")
+      inspector << "├── then_keyword_loc: #{inspector.location(then_keyword_loc)}\n"
       if (statements = self.statements).nil?
         inspector << "├── statements: ∅\n"
       else

data/lib/prism/node_ext.rb

@@ -61,7 +61,8 @@ module Prism
   end
 
   class ConstantReadNode < Node
-    # Returns the list of parts for the full name of this constant. For example: [:Foo]
+    # Returns the list of parts for the full name of this constant.
+    # For example: [:Foo]
     def full_name_parts
       [name]
     end
@@ -73,7 +74,16 @@ module Prism
   end
 
   class ConstantPathNode < Node
-    # Returns the list of parts for the full name of this constant path. For example: [:Foo, :Bar]
+    # An error class raised when dynamic parts are found while computing a
+    # constant path's full name. For example:
+    # Foo::Bar::Baz -> does not raise because all parts of the constant path are
+    # simple constants
+    # var::Bar::Baz -> raises because the first part of the constant path is a
+    # local variable
+    class DynamicPartsInConstantPathError < StandardError; end
+
+    # Returns the list of parts for the full name of this constant path.
+    # For example: [:Foo, :Bar]
     def full_name_parts
       parts = [child.name]
       current = parent
@@ -83,6 +93,10 @@ module Prism
         current = current.parent
       end
 
+      unless current.is_a?(ConstantReadNode)
+        raise DynamicPartsInConstantPathError, "Constant path contains dynamic parts. Cannot compute full name"
+      end
+
       parts.unshift(current&.name || :"")
     end
 
@@ -93,7 +107,8 @@ module Prism
   end
 
   class ConstantPathTargetNode < Node
-    # Returns the list of parts for the full name of this constant path. For example: [:Foo, :Bar]
+    # Returns the list of parts for the full name of this constant path.
+    # For example: [:Foo, :Bar]
     def full_name_parts
       (parent&.full_name_parts || [:""]).push(child.name)
     end
@@ -103,4 +118,47 @@ module Prism
       full_name_parts.join("::")
     end
   end
+
+  class ParametersNode < Node
+    # Mirrors the Method#parameters method.
+    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
+  end
 end