prism 0.16.0 → 0.17.1

data/lib/prism/debug.rb

@@ -4,7 +4,9 @@ module Prism
   # This module is used for testing and debugging and is not meant to be used by
   # consumers of this library.
   module Debug
-    class ISeq
+    # A wrapper around a RubyVM::InstructionSequence that provides a more
+    # convenient interface for accessing parts of the iseq.
+    class ISeq # :nodoc:
       attr_reader :parts
 
       def initialize(parts)
@@ -42,6 +44,11 @@ module Prism
       end
     end
 
+    private_constant :ISeq
+
+    # :call-seq:
+    #   Debug::cruby_locals(source) -> Array
+    #
     # For the given source, compiles with CRuby and returns a list of all of the
     # sets of local variables that were encountered.
     def self.cruby_locals(source)
@@ -76,8 +83,16 @@ module Prism
       end
     end
 
+    # Used to hold the place of a local that will be in the local table but
+    # cannot be accessed directly from the source code. For example, the
+    # iteration variable in a for loop or the positional parameter on a method
+    # definition that is destructured.
     AnonymousLocal = Object.new
+    private_constant :AnonymousLocal
 
+    # :call-seq:
+    #   Debug::prism_locals(source) -> Array
+    #
     # For the given source, parses with prism and returns a list of all of the
     # sets of local variables that were encountered.
     def self.prism_locals(source)
@@ -114,8 +129,8 @@ module Prism
                   AnonymousLocal
                 end
               end,
-              *params.keywords.reject(&:value).map(&:name),
-              *params.keywords.select(&:value).map(&:name)
+              *params.keywords.grep(RequiredKeywordParameterNode).map(&:name),
+              *params.keywords.grep(OptionalKeywordParameterNode).map(&:name),
             ]
 
             sorted << AnonymousLocal if params.keywords.any?
@@ -164,12 +179,13 @@ module Prism
       locals
     end
 
+    # :call-seq:
+    #   Debug::newlines(source) -> Array
+    #
+    # For the given source string, return the byte offsets of every newline in
+    # the source.
     def self.newlines(source)
       Prism.parse(source).source.offsets
     end
-
-    def self.parse_serialize_file(filepath)
-      parse_serialize_file_metadata(filepath, [filepath.bytesize, filepath.b, 0].pack("LA*L"))
-    end
   end
 end

data/lib/prism/dispatcher.rb

@@ -41,23 +41,24 @@ module Prism
     # attr_reader listeners: Hash[Symbol, Array[Listener]]
     attr_reader :listeners
 
+    # Initialize a new dispatcher.
     def initialize
       @listeners = {}
     end
 
-    # Register a listener for one or more events
+    # Register a listener for one or more events.
     #
     # def register: (Listener, *Symbol) -> void
     def register(listener, *events)
       events.each { |event| (listeners[event] ||= []) << listener }
     end
 
-    # Walks `root` dispatching events to all registered listeners
+    # Walks `root` dispatching events to all registered listeners.
     #
     # def dispatch: (Node) -> void
     alias dispatch visit
 
-    # Dispatches a single event for `node` to all registered listeners
+    # Dispatches a single event for `node` to all registered listeners.
     #
     # def dispatch_once: (Node) -> void
     def dispatch_once(node)
@@ -736,14 +737,6 @@ module Prism
       listeners[:on_keyword_hash_node_leave]&.each { |listener| listener.on_keyword_hash_node_leave(node) }
     end
 
-    # Dispatch enter and leave events for KeywordParameterNode nodes and continue
-    # walking the tree.
-    def visit_keyword_parameter_node(node)
-      listeners[:on_keyword_parameter_node_enter]&.each { |listener| listener.on_keyword_parameter_node_enter(node) }
-      super
-      listeners[:on_keyword_parameter_node_leave]&.each { |listener| listener.on_keyword_parameter_node_leave(node) }
-    end
-
     # Dispatch enter and leave events for KeywordRestParameterNode nodes and continue
     # walking the tree.
     def visit_keyword_rest_parameter_node(node)
@@ -904,6 +897,14 @@ module Prism
       listeners[:on_numbered_reference_read_node_leave]&.each { |listener| listener.on_numbered_reference_read_node_leave(node) }
     end
 
+    # Dispatch enter and leave events for OptionalKeywordParameterNode nodes and continue
+    # walking the tree.
+    def visit_optional_keyword_parameter_node(node)
+      listeners[:on_optional_keyword_parameter_node_enter]&.each { |listener| listener.on_optional_keyword_parameter_node_enter(node) }
+      super
+      listeners[:on_optional_keyword_parameter_node_leave]&.each { |listener| listener.on_optional_keyword_parameter_node_leave(node) }
+    end
+
     # Dispatch enter and leave events for OptionalParameterNode nodes and continue
     # walking the tree.
     def visit_optional_parameter_node(node)
@@ -1008,6 +1009,14 @@ module Prism
       listeners[:on_regular_expression_node_leave]&.each { |listener| listener.on_regular_expression_node_leave(node) }
     end
 
+    # Dispatch enter and leave events for RequiredKeywordParameterNode nodes and continue
+    # walking the tree.
+    def visit_required_keyword_parameter_node(node)
+      listeners[:on_required_keyword_parameter_node_enter]&.each { |listener| listener.on_required_keyword_parameter_node_enter(node) }
+      super
+      listeners[:on_required_keyword_parameter_node_leave]&.each { |listener| listener.on_required_keyword_parameter_node_leave(node) }
+    end
+
     # Dispatch enter and leave events for RequiredParameterNode nodes and continue
     # walking the tree.
     def visit_required_parameter_node(node)
@@ -1208,7 +1217,7 @@ module Prism
       listeners[:on_yield_node_leave]&.each { |listener| listener.on_yield_node_leave(node) }
     end
 
-    class DispatchOnce < Visitor
+    class DispatchOnce < Visitor # :nodoc:
       attr_reader :listeners
 
       def initialize(listeners)
@@ -1719,12 +1728,6 @@ module Prism
         listeners[:on_keyword_hash_node_leave]&.each { |listener| listener.on_keyword_hash_node_leave(node) }
       end
 
-      # Dispatch enter and leave events for KeywordParameterNode nodes.
-      def visit_keyword_parameter_node(node)
-        listeners[:on_keyword_parameter_node_enter]&.each { |listener| listener.on_keyword_parameter_node_enter(node) }
-        listeners[:on_keyword_parameter_node_leave]&.each { |listener| listener.on_keyword_parameter_node_leave(node) }
-      end
-
       # Dispatch enter and leave events for KeywordRestParameterNode nodes.
       def visit_keyword_rest_parameter_node(node)
         listeners[:on_keyword_rest_parameter_node_enter]&.each { |listener| listener.on_keyword_rest_parameter_node_enter(node) }
@@ -1845,6 +1848,12 @@ module Prism
         listeners[:on_numbered_reference_read_node_leave]&.each { |listener| listener.on_numbered_reference_read_node_leave(node) }
       end
 
+      # Dispatch enter and leave events for OptionalKeywordParameterNode nodes.
+      def visit_optional_keyword_parameter_node(node)
+        listeners[:on_optional_keyword_parameter_node_enter]&.each { |listener| listener.on_optional_keyword_parameter_node_enter(node) }
+        listeners[:on_optional_keyword_parameter_node_leave]&.each { |listener| listener.on_optional_keyword_parameter_node_leave(node) }
+      end
+
       # Dispatch enter and leave events for OptionalParameterNode nodes.
       def visit_optional_parameter_node(node)
         listeners[:on_optional_parameter_node_enter]&.each { |listener| listener.on_optional_parameter_node_enter(node) }
@@ -1923,6 +1932,12 @@ module Prism
         listeners[:on_regular_expression_node_leave]&.each { |listener| listener.on_regular_expression_node_leave(node) }
       end
 
+      # Dispatch enter and leave events for RequiredKeywordParameterNode nodes.
+      def visit_required_keyword_parameter_node(node)
+        listeners[:on_required_keyword_parameter_node_enter]&.each { |listener| listener.on_required_keyword_parameter_node_enter(node) }
+        listeners[:on_required_keyword_parameter_node_leave]&.each { |listener| listener.on_required_keyword_parameter_node_leave(node) }
+      end
+
       # Dispatch enter and leave events for RequiredParameterNode nodes.
       def visit_required_parameter_node(node)
         listeners[:on_required_parameter_node_enter]&.each { |listener| listener.on_required_parameter_node_enter(node) }

data/lib/prism/dsl.rb

@@ -462,11 +462,6 @@ module Prism
       KeywordHashNode.new(elements, location)
     end
 
-    # Create a new KeywordParameterNode node
-    def KeywordParameterNode(name, name_loc, value, location = Location())
-      KeywordParameterNode.new(name, name_loc, value, location)
-    end
-
     # Create a new KeywordRestParameterNode node
     def KeywordRestParameterNode(name, name_loc, operator_loc, location = Location())
       KeywordRestParameterNode.new(name, name_loc, operator_loc, location)
@@ -567,6 +562,11 @@ module Prism
       NumberedReferenceReadNode.new(number, location)
     end
 
+    # Create a new OptionalKeywordParameterNode node
+    def OptionalKeywordParameterNode(name, name_loc, value, location = Location())
+      OptionalKeywordParameterNode.new(name, name_loc, value, location)
+    end
+
     # Create a new OptionalParameterNode node
     def OptionalParameterNode(name, name_loc, operator_loc, value, location = Location())
       OptionalParameterNode.new(name, name_loc, operator_loc, value, location)
@@ -632,6 +632,11 @@ module Prism
       RegularExpressionNode.new(opening_loc, content_loc, closing_loc, unescaped, flags, location)
     end
 
+    # Create a new RequiredKeywordParameterNode node
+    def RequiredKeywordParameterNode(name, name_loc, location = Location())
+      RequiredKeywordParameterNode.new(name, name_loc, location)
+    end
+
     # Create a new RequiredParameterNode node
     def RequiredParameterNode(name, location = Location())
       RequiredParameterNode.new(name, location)

data/lib/prism/ffi.rb

@@ -9,7 +9,7 @@ require "ffi"
 module Prism
   BACKEND = :FFI
 
-  module LibRubyParser
+  module LibRubyParser # :nodoc:
     extend FFI::Library
 
     # Define the library that we will be pulling functions from. Note that this
@@ -69,10 +69,10 @@ module Prism
     load_exported_functions_from(
       "prism.h",
       "pm_version",
-      "pm_parse_serialize",
-      "pm_parse_serialize_comments",
-      "pm_lex_serialize",
-      "pm_parse_lex_serialize"
+      "pm_serialize_parse",
+      "pm_serialize_parse_comments",
+      "pm_serialize_lex",
+      "pm_serialize_parse_lex"
     )
 
     load_exported_functions_from(
@@ -95,7 +95,7 @@ module Prism
 
     # This object represents a pm_buffer_t. We only use it as an opaque pointer,
     # so it doesn't need to know the fields of pm_buffer_t.
-    class PrismBuffer
+    class PrismBuffer # :nodoc:
       SIZEOF = LibRubyParser.pm_buffer_sizeof
 
       attr_reader :pointer
@@ -133,7 +133,7 @@ module Prism
 
     # This object represents a pm_string_t. We only use it as an opaque pointer,
     # so it doesn't have to be an FFI::Struct.
-    class PrismString
+    class PrismString # :nodoc:
       SIZEOF = LibRubyParser.pm_string_sizeof
 
       attr_reader :pointer
@@ -167,14 +167,6 @@ module Prism
         end
       end
     end
-
-    def self.dump_internal(source, source_size, filepath)
-      PrismBuffer.with do |buffer|
-        metadata = [filepath.bytesize, filepath.b, 0].pack("LA*L") if filepath
-        pm_parse_serialize(source, source_size, buffer.pointer, metadata)
-        buffer.read
-      end
-    end
   end
 
   # Mark the LibRubyParser module as private as it should only be called through
@@ -184,93 +176,153 @@ module Prism
   # The version constant is set by reading the result of calling pm_version.
   VERSION = LibRubyParser.pm_version.read_string
 
-  # Mirror the Prism.dump API by using the serialization API.
-  def self.dump(code, filepath = nil)
-    LibRubyParser.dump_internal(code, code.bytesize, filepath)
-  end
+  class << self
+    # Mirror the Prism.dump API by using the serialization API.
+    def dump(code, **options)
+      LibRubyParser::PrismBuffer.with do |buffer|
+        LibRubyParser.pm_serialize_parse(buffer.pointer, code, code.bytesize, dump_options(options))
+        buffer.read
+      end
+    end
 
-  # Mirror the Prism.dump_file API by using the serialization API.
-  def self.dump_file(filepath)
-    LibRubyParser::PrismString.with(filepath) do |string|
-      LibRubyParser.dump_internal(string.source, string.length, filepath)
+    # Mirror the Prism.dump_file API by using the serialization API.
+    def dump_file(filepath, **options)
+      LibRubyParser::PrismString.with(filepath) do |string|
+        dump(string.read, **options, filepath: filepath)
+      end
     end
-  end
 
-  # Mirror the Prism.lex API by using the serialization API.
-  def self.lex(code, filepath = nil)
-    LibRubyParser::PrismBuffer.with do |buffer|
-      LibRubyParser.pm_lex_serialize(code, code.bytesize, filepath, buffer.pointer)
-      Serialize.load_tokens(Source.new(code), buffer.read)
+    # Mirror the Prism.lex API by using the serialization API.
+    def lex(code, **options)
+      LibRubyParser::PrismBuffer.with do |buffer|
+        LibRubyParser.pm_serialize_lex(buffer.pointer, code, code.bytesize, dump_options(options))
+        Serialize.load_tokens(Source.new(code), buffer.read)
+      end
     end
-  end
 
-  # Mirror the Prism.lex_file API by using the serialization API.
-  def self.lex_file(filepath)
-    LibRubyParser::PrismString.with(filepath) do |string|
-      lex(string.read, filepath)
+    # Mirror the Prism.lex_file API by using the serialization API.
+    def lex_file(filepath, **options)
+      LibRubyParser::PrismString.with(filepath) do |string|
+        lex(string.read, **options, filepath: filepath)
+      end
     end
-  end
 
-  # Mirror the Prism.parse API by using the serialization API.
-  def self.parse(code, filepath = nil)
-    Prism.load(code, dump(code, filepath))
-  end
+    # Mirror the Prism.parse API by using the serialization API.
+    def parse(code, **options)
+      Prism.load(code, dump(code, **options))
+    end
 
-  # Mirror the Prism.parse_file API by using the serialization API. This uses
-  # native strings instead of Ruby strings because it allows us to use mmap when
-  # it is available.
-  def self.parse_file(filepath)
-    LibRubyParser::PrismString.with(filepath) do |string|
-      parse(string.read, filepath)
+    # Mirror the Prism.parse_file API by using the serialization API. This uses
+    # native strings instead of Ruby strings because it allows us to use mmap when
+    # it is available.
+    def parse_file(filepath, **options)
+      LibRubyParser::PrismString.with(filepath) do |string|
+        parse(string.read, **options, filepath: filepath)
+      end
     end
-  end
 
-  # Mirror the Prism.parse_comments API by using the serialization API.
-  def self.parse_comments(code, filepath = nil)
-    LibRubyParser::PrismBuffer.with do |buffer|
-      metadata = [filepath.bytesize, filepath.b, 0].pack("LA*L") if filepath
-      LibRubyParser.pm_parse_serialize_comments(code, code.bytesize, buffer.pointer, metadata)
+    # Mirror the Prism.parse_comments API by using the serialization API.
+    def parse_comments(code, **options)
+      LibRubyParser::PrismBuffer.with do |buffer|
+        LibRubyParser.pm_serialize_parse_comments(buffer.pointer, code, code.bytesize, dump_options(options))
 
-      source = Source.new(code)
-      loader = Serialize::Loader.new(source, buffer.read)
+        source = Source.new(code)
+        loader = Serialize::Loader.new(source, buffer.read)
 
-      loader.load_header
-      loader.load_force_encoding
-      loader.load_comments
+        loader.load_header
+        loader.load_force_encoding
+        loader.load_start_line
+        loader.load_comments
+      end
     end
-  end
 
-  # Mirror the Prism.parse_file_comments API by using the serialization
-  # API. This uses native strings instead of Ruby strings because it allows us
-  # to use mmap when it is available.
-  def self.parse_file_comments(filepath)
-    LibRubyParser::PrismString.with(filepath) do |string|
-      parse_comments(string.read, filepath)
+    # Mirror the Prism.parse_file_comments API by using the serialization
+    # API. This uses native strings instead of Ruby strings because it allows us
+    # to use mmap when it is available.
+    def parse_file_comments(filepath, **options)
+      LibRubyParser::PrismString.with(filepath) do |string|
+        parse_comments(string.read, **options, filepath: filepath)
+      end
     end
-  end
 
-  # Mirror the Prism.parse_lex API by using the serialization API.
-  def self.parse_lex(code, filepath = nil)
-    LibRubyParser::PrismBuffer.with do |buffer|
-      metadata = [filepath.bytesize, filepath.b, 0].pack("LA*L") if filepath
-      LibRubyParser.pm_parse_lex_serialize(code, code.bytesize, buffer.pointer, metadata)
+    # Mirror the Prism.parse_lex API by using the serialization API.
+    def parse_lex(code, **options)
+      LibRubyParser::PrismBuffer.with do |buffer|
+        LibRubyParser.pm_serialize_parse_lex(buffer.pointer, code, code.bytesize, dump_options(options))
 
-      source = Source.new(code)
-      loader = Serialize::Loader.new(source, buffer.read)
+        source = Source.new(code)
+        loader = Serialize::Loader.new(source, buffer.read)
 
-      tokens = loader.load_tokens
-      node, comments, magic_comments, errors, warnings = loader.load_nodes
+        tokens = loader.load_tokens
+        node, comments, magic_comments, errors, warnings = loader.load_nodes
+        tokens.each { |token,| token.value.force_encoding(loader.encoding) }
 
-      tokens.each { |token,| token.value.force_encoding(loader.encoding) }
+        ParseResult.new([node, tokens], comments, magic_comments, errors, warnings, source)
+      end
+    end
 
-      ParseResult.new([node, tokens], comments, magic_comments, errors, warnings, source)
+    # Mirror the Prism.parse_lex_file API by using the serialization API.
+    def parse_lex_file(filepath, **options)
+      LibRubyParser::PrismString.with(filepath) do |string|
+        parse_lex(string.read, **options, filepath: filepath)
+      end
     end
-  end
 
-  # Mirror the Prism.parse_lex_file API by using the serialization API.
-  def self.parse_lex_file(filepath)
-    LibRubyParser::PrismString.with(filepath) do |string|
-      parse_lex(string.read, filepath)
+    private
+
+    # Convert the given options into a serialized options string.
+    def dump_options(options)
+      template = +""
+      values = []
+
+      template << "L"
+      if (filepath = options[:filepath])
+        values.push(filepath.bytesize, filepath.b)
+        template << "A*"
+      else
+        values << 0
+      end
+
+      template << "L"
+      values << options.fetch(:line, 1)
+
+      template << "L"
+      if (encoding = options[:encoding])
+        name = encoding.name
+        values.push(name.bytesize, name.b)
+        template << "A*"
+      else
+        values << 0
+      end
+
+      template << "C"
+      values << (options.fetch(:frozen_string_literal, false) ? 1 : 0)
+
+      template << "C"
+      values << (options[:verbose] ? 0 : 1)
+
+      template << "L"
+      if (scopes = options[:scopes])
+        values << scopes.length
+
+        scopes.each do |scope|
+          template << "L"
+          values << scope.length
+
+          scope.each do |local|
+            name = local.name
+            template << "L"
+            values << name.bytesize
+
+            template << "A*"
+            values << name.b
+          end
+        end
+      else
+        values << 0
+      end
+
+      values.pack(template)
     end
   end
 end

data/lib/prism/lex_compat.rb

@@ -8,7 +8,7 @@ module Prism
   # of cases, this is a one-to-one mapping of the token type. Everything else
   # generally lines up. However, there are a few cases that require special
   # handling.
-  class LexCompat
+  class LexCompat # :nodoc:
     # This is a mapping of prism token types to Ripper token types. This is a
     # many-to-one mapping because we split up our token types, whereas Ripper
     # tends to group them.
@@ -184,18 +184,22 @@ module Prism
     # However, we add a couple of convenience methods onto them to make them a
     # little easier to work with. We delegate all other methods to the array.
     class Token < SimpleDelegator
+      # The location of the token in the source.
       def location
         self[0]
       end
 
+      # The type of the token.
       def event
         self[1]
       end
 
+      # The slice of the source that this token represents.
       def value
         self[2]
       end
 
+      # The state of the lexer when this token was produced.
       def state
         self[3]
       end
@@ -204,7 +208,7 @@ module Prism
     # Ripper doesn't include the rest of the token in the event, so we need to
     # trim it down to just the content on the first line when comparing.
     class EndContentToken < Token
-      def ==(other)
+      def ==(other) # :nodoc:
         [self[0], self[1], self[2][0..self[2].index("\n")], self[3]] == other
       end
     end
@@ -212,7 +216,7 @@ module Prism
     # Tokens where state should be ignored
     # used for :on_comment, :on_heredoc_end, :on_embexpr_end
     class IgnoreStateToken < Token
-      def ==(other)
+      def ==(other) # :nodoc:
         self[0...-1] == other[0...-1]
       end
     end
@@ -222,7 +226,7 @@ module Prism
     # through named captures in regular expressions). In that case we don't
     # compare the state.
     class IdentToken < Token
-      def ==(other)
+      def ==(other) # :nodoc:
         (self[0...-1] == other[0...-1]) && (
           (other[3] == Ripper::EXPR_LABEL | Ripper::EXPR_END) ||
           (other[3] & Ripper::EXPR_ARG_ANY != 0)
@@ -233,7 +237,7 @@ module Prism
     # Ignored newlines can occasionally have a LABEL state attached to them, so
     # we compare the state differently here.
     class IgnoredNewlineToken < Token
-      def ==(other)
+      def ==(other) # :nodoc:
         return false unless self[0...-1] == other[0...-1]
 
         if self[4] == Ripper::EXPR_ARG | Ripper::EXPR_LABELED
@@ -253,7 +257,7 @@ module Prism
     # more accurately, so we need to allow comparing against both END and
     # END|LABEL.
     class ParamToken < Token
-      def ==(other)
+      def ==(other) # :nodoc:
         (self[0...-1] == other[0...-1]) && (
           (other[3] == Ripper::EXPR_END) ||
           (other[3] == Ripper::EXPR_END | Ripper::EXPR_LABEL)
@@ -264,12 +268,12 @@ module Prism
     # A heredoc in this case is a list of tokens that belong to the body of the
     # heredoc that should be appended onto the list of tokens when the heredoc
     # closes.
-    module Heredoc
+    module Heredoc # :nodoc:
       # Heredocs that are no dash or tilde heredocs are just a list of tokens.
       # We need to keep them around so that we can insert them in the correct
       # order back into the token stream and set the state of the last token to
       # the state that the heredoc was opened in.
-      class PlainHeredoc
+      class PlainHeredoc # :nodoc:
         attr_reader :tokens
 
         def initialize
@@ -288,7 +292,7 @@ module Prism
       # Dash heredocs are a little more complicated. They are a list of tokens
       # that need to be split on "\\\n" to mimic Ripper's behavior. We also need
       # to keep track of the state that the heredoc was opened in.
-      class DashHeredoc
+      class DashHeredoc # :nodoc:
         attr_reader :split, :tokens
 
         def initialize(split)
@@ -347,7 +351,7 @@ module Prism
       # insert them into the stream in the correct order. As such, we can do
       # some extra manipulation on the tokens to make them match Ripper's
       # output by mirroring the dedent logic that Ripper uses.
-      class DedentingHeredoc
+      class DedentingHeredoc # :nodoc:
         TAB_WIDTH = 8
 
         attr_reader :tokens, :dedent_next, :dedent, :embexpr_balance
@@ -588,11 +592,13 @@ module Prism
       end
     end
 
-    attr_reader :source, :filepath
+    private_constant :Heredoc
 
-    def initialize(source, filepath = "")
+    attr_reader :source, :options
+
+    def initialize(source, **options)
       @source = source
-      @filepath = filepath || ""
+      @options = options
     end
 
     def result
@@ -601,7 +607,7 @@ module Prism
       state = :default
       heredoc_stack = [[]]
 
-      result = Prism.lex(source, @filepath)
+      result = Prism.lex(source, **options)
       result_value = result.value
       previous_state = nil
 
@@ -829,9 +835,11 @@ module Prism
     end
   end
 
+  private_constant :LexCompat
+
   # This is a class that wraps the Ripper lexer to produce almost exactly the
   # same tokens.
-  class LexRipper
+  class LexRipper # :nodoc:
     attr_reader :source
 
     def initialize(source)
@@ -869,4 +877,6 @@ module Prism
       results
     end
   end
+
+  private_constant :LexRipper
 end

data/lib/prism/mutation_compiler.rb

@@ -430,11 +430,6 @@ module Prism
       node.copy(elements: visit_all(node.elements))
     end
 
-    # Copy a KeywordParameterNode node
-    def visit_keyword_parameter_node(node)
-      node.copy(value: visit(node.value))
-    end
-
     # Copy a KeywordRestParameterNode node
     def visit_keyword_rest_parameter_node(node)
       node.copy
@@ -535,6 +530,11 @@ module Prism
       node.copy
     end
 
+    # Copy a OptionalKeywordParameterNode node
+    def visit_optional_keyword_parameter_node(node)
+      node.copy(value: visit(node.value))
+    end
+
     # Copy a OptionalParameterNode node
     def visit_optional_parameter_node(node)
       node.copy(value: visit(node.value))
@@ -600,6 +600,11 @@ module Prism
       node.copy
     end
 
+    # Copy a RequiredKeywordParameterNode node
+    def visit_required_keyword_parameter_node(node)
+      node.copy
+    end
+
     # Copy a RequiredParameterNode node
     def visit_required_parameter_node(node)
       node.copy