evilution 1.2.0 → 1.4.0

data/lib/evilution/mutator/operator/dig_to_fetch_chain.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Make the first step of a `dig` strict: `config.dig(:db, :host)` becomes
+# `config.fetch(:db).dig(:host)`. The reverse of index_to_dig.
+#
+# `dig` returns nil when the first key is missing or holds nil; the fetch
+# chain raises there instead (KeyError / IndexError, or NoMethodError on
+# `nil.dig`). A survivor means no test reaches the lookup with that key
+# absent.
+#
+# Only calls with two or more positional keys qualify; the remaining keys
+# keep their original formatting.
+class Evilution::Mutator::Operator::DigToFetchChain < Evilution::Mutator::Base
+  NON_POSITIONAL = [Prism::SplatNode, Prism::KeywordHashNode, Prism::ForwardingArgumentsNode].freeze
+  private_constant :NON_POSITIONAL
+
+  def visit_call_node(node)
+    rewrite(node) if node.name == :dig && node.receiver && node.block.nil?
+    super
+  end
+
+  private
+
+  # Replace `dig(first, ` with `fetch(first).dig(` — up to the second key —
+  # keeping whatever opened the argument list (`(`, a newline, a space).
+  def rewrite(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [first, second, *]]
+    return unless positional_keys?(node.arguments.arguments)
+
+    start = node.message_loc.start_offset
+    add_mutation(offset: start, length: second.start_offset - start, replacement: fetch_prefix(node, first), node: node)
+  end
+
+  def positional_keys?(keys)
+    keys.none? { |key| NON_POSITIONAL.any? { |type| key.is_a?(type) } }
+  end
+
+  def fetch_prefix(node, first)
+    message_end = node.message_loc.end_offset
+    opener = byteslice_source(message_end, first.start_offset - message_end)
+    "fetch(#{source_of(first)}).dig#{opener}"
+  end
+end

data/lib/evilution/mutator/operator/double_negation_removal.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a double negation with its operand: `!!value` becomes `value`, and
+# the same for the `not not value` keyword form.
+#
+# A survivor means no test distinguishes a truthy object from `true` (or nil
+# from `false`) — the boolean coercion is never observed.
+class Evilution::Mutator::Operator::DoubleNegationRemoval < Evilution::Mutator::Base
+  def visit_call_node(node)
+    inner = node.receiver
+    promote_child(node, inner.receiver) if negation?(node) && negation?(inner)
+    super
+  end
+
+  private
+
+  def negation?(node)
+    node.is_a?(Prism::CallNode) && node.name == :!
+  end
+end

data/lib/evilution/mutator/operator/dynamic_dispatch_resolution.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Resolve a dynamic dispatch with a literal symbol into a direct call:
+# `target.send(:reset)` becomes `target.reset`, and the same for `__send__`
+# and `public_send`. Remaining arguments, a block-pass and a literal block
+# stay attached.
+#
+# The two forms differ only in visibility checks, so the mutant is emitted
+# only where those checks can disagree:
+#
+# - send / __send__ on an explicit receiver other than self: the direct call
+#   raises NoMethodError for a private method. With an implicit or self
+#   receiver a private method resolves either way (Ruby 2.7+).
+# - public_send with an implicit or self receiver: the direct call reaches a
+#   private method that public_send refuses. On any other receiver both
+#   refuse it, and only a protected method called from inside its class
+#   would differ.
+#
+# method_missing is reached the same way by both forms.
+class Evilution::Mutator::Operator::DynamicDispatchResolution < Evilution::Mutator::Base
+  SEND_SELECTORS = %i[send __send__].freeze
+  private_constant :SEND_SELECTORS
+
+  OPERATOR_NAMES = %w[
+    + - * / % ** == != < > <= >= <=> === =~ !~ ! [] []= << >> & | ^ ~ +@ -@
+  ].to_set.freeze
+  private_constant :OPERATOR_NAMES
+
+  METHOD_NAME = /\A[[:alpha:]_][[:alnum:]_]*[?!=]?\z/
+  private_constant :METHOD_NAME
+
+  def visit_call_node(node)
+    selector = literal_selector(node)
+    resolve(node, selector) if selector && visibility_can_differ?(node)
+    super
+  end
+
+  private
+
+  def literal_selector(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [Prism::SymbolNode => symbol, *]]
+
+    name = symbol.unescaped
+    name if name.match?(METHOD_NAME) || OPERATOR_NAMES.include?(name)
+  end
+
+  def visibility_can_differ?(node)
+    self_receiver = node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+
+    if SEND_SELECTORS.include?(node.name)
+      !self_receiver
+    else
+      node.name == :public_send && self_receiver
+    end
+  end
+
+  def resolve(node, selector)
+    start = node.message_loc.start_offset
+    following = following_item(node)
+
+    if following
+      replacement = "#{selector}#{node.opening_loc ? "(" : " "}"
+      finish = following.start_offset
+    else
+      replacement = selector
+      finish = node.closing_loc ? node.closing_loc.end_offset : node.arguments.end_offset
+    end
+
+    add_mutation(offset: start, length: finish - start, replacement: replacement, node: node)
+  end
+
+  # The argument after the selector, or the block-pass when the selector is
+  # the only argument.
+  def following_item(node)
+    node.arguments.arguments[1] || (node.block if node.block.is_a?(Prism::BlockArgumentNode))
+  end
+end

data/lib/evilution/mutator/operator/exception_swallow.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Swallow the error of a statement that raises by convention:
+# `record.save!` becomes `record.save! rescue nil`.
+#
+# The mutant behaves like the original until the statement fails; then it
+# carries on with nil instead of raising. A survivor means no example makes
+# that statement fail and checks the error comes out. It is the inverse of
+# RescueRemoval: handling is added where there is none.
+#
+# Only calls whose failure is part of their contract are reached: bang
+# methods, `fetch`, and the conversion functions `Integer`, `Float` and
+# `Rational`. Wrapping every statement would mostly report that no test makes
+# a log line raise. Statements already covered by a rescue are left alone, as
+# is `raise`, whose swallowed form behaves as deleting the statement.
+class Evilution::Mutator::Operator::ExceptionSwallow < Evilution::Mutator::Base
+  CONVERSION_FUNCTIONS = %i[Integer Float Rational].freeze
+
+  # A bang method name, as opposed to the `!` and `!=` operators.
+  BANG_METHOD = /\w!\z/
+
+  # Bangs that do not raise: Ruby's in-place methods mark a change to the
+  # receiver, and exit! ends the process without raising.
+  NON_RAISING_BANGS = %i[
+    uniq! sort! sort_by! select! filter! reject! map! collect! compact! flatten!
+    shuffle! reverse! rotate! slice! merge! transform_keys! transform_values!
+    gsub! sub! strip! lstrip! rstrip! chomp! chop! squeeze! tr! tr_s! delete!
+    downcase! upcase! capitalize! swapcase! unicode_normalize! scrub! encode!
+    exit!
+  ].freeze
+
+  # Assignments whose value is the statement's call.
+  WRITE_TYPES = [
+    Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode,
+    Prism::ClassVariableWriteNode, Prism::GlobalVariableWriteNode
+  ].freeze
+
+  def visit_statements_node(node)
+    node.body.each { |statement| swallow(statement) }
+    super
+  end
+
+  # Everything under a `begin` (or a `def` or block body) with a rescue clause
+  # is already handled there, so the visitor does not descend into it.
+  def visit_begin_node(node)
+    super if node.rescue_clause.nil?
+  end
+
+  private
+
+  def swallow(statement)
+    call = statement_call(statement)
+    return unless call && raising?(call)
+
+    add_mutation(
+      offset: statement.location.end_offset,
+      length: 0,
+      replacement: " rescue nil",
+      node: call
+    )
+  end
+
+  def statement_call(statement)
+    statement = statement.value if WRITE_TYPES.include?(statement.class)
+    statement if statement.is_a?(Prism::CallNode)
+  end
+
+  def raising?(call)
+    name = call.name
+    return !NON_RAISING_BANGS.include?(name) if name.to_s.match?(BANG_METHOD)
+    return raising_fetch?(call) if name == :fetch
+
+    call.receiver.nil? && CONVERSION_FUNCTIONS.include?(name)
+  end
+
+  # With a default value or a block, fetch returns that instead of raising.
+  def raising_fetch?(call)
+    return false if call.receiver.nil? || call.block
+
+    call.arguments.nil? || call.arguments.arguments.length == 1
+  end
+end

data/lib/evilution/mutator/operator/format_specifier_swap.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Loosen the conversion specifiers of a literal format string, one at a time:
+#
+#   format("%05d", n)    ->  format("%d", n)     flags and width dropped
+#   sprintf("%.2f", x)   ->  sprintf("%f", x)    precision dropped
+#                        ->  sprintf("%s", x)    rendered as a plain string
+#
+# A survivor means the output is produced but its shape — padding, decimals,
+# number base — is never asserted.
+#
+# Reaches the format string of receiverless `format`, `sprintf` and `printf`
+# and the string receiver of `"..." % args`, when it is a plain literal. Integer
+# conversions (`%d`, `%i`, `%u`) are not turned into `%s`: for an integer
+# argument both print the same digits.
+class Evilution::Mutator::Operator::FormatSpecifierSwap < Evilution::Mutator::Base
+  FORMAT_METHODS = %i[format sprintf printf].freeze
+
+  # `%%` and `%{name}` are matched so they are not mistaken for the start of
+  # a specifier; neither is mutated.
+  SPECIFIER = /
+    %(?:
+      %
+      | \{\w+\}
+      | (?<name><\w+>)?(?<flags>[-+\ 0\#]*)(?<width>\d+|\*)?(?:\.(?<precision>\d+|\*))?(?<type>[a-zA-Z])
+    )
+  /x
+
+  # Conversions whose output differs from `%s` for the values they take.
+  STRINGIFIABLE_TYPES = %w[f e E g G a A x X o b B].freeze
+
+  def visit_call_node(node)
+    format_string = format_string_of(node)
+    mutate_specifiers(node, format_string) if format_string
+    super
+  end
+
+  private
+
+  def format_string_of(node)
+    candidate =
+      if node.receiver.nil? && FORMAT_METHODS.include?(node.name)
+        first_argument(node)
+      elsif node.name == :%
+        node.receiver
+      end
+
+    candidate if plain_literal?(candidate)
+  end
+
+  def first_argument(node)
+    node.arguments.arguments.first if node.arguments
+  end
+
+  # A heredoc's content sits after the line that opens it, so edits inside
+  # it are left alone along with interpolated strings. Only `%w[]` elements
+  # lack an opening delimiter, and those never stand here on their own.
+  def plain_literal?(node)
+    node.is_a?(Prism::StringNode) && !node.opening_loc.slice.start_with?("<<")
+  end
+
+  def mutate_specifiers(node, format_string)
+    specifiers(format_string).each do |match, offset|
+      variants(match).each do |replacement|
+        add_mutation(offset: offset, length: match[0].bytesize, replacement: replacement, node: node)
+      end
+    end
+  end
+
+  # Each conversion specifier with its offset in the file. The scan runs over
+  # the source text between the quotes, so offsets line up with the file even
+  # when the string holds escapes.
+  def specifiers(format_string)
+    content = format_string.content_loc
+    text = byteslice_source(content.start_offset, content.length)
+
+    text.to_enum(:scan, SPECIFIER).filter_map do
+      match = Regexp.last_match
+      [match, content.start_offset + match.byteoffset(0).first] unless match[:type].nil?
+    end
+  end
+
+  # A `*` width or precision consumes an argument of its own, so dropping it
+  # would shift every argument after it.
+  def variants(match)
+    return [] if [match[:width], match[:precision]].include?("*")
+
+    name = match[:name]
+    replacements = []
+    replacements << "%#{name}#{match[:type]}" if modifiers?(match)
+    replacements << "%#{name}s" if STRINGIFIABLE_TYPES.include?(match[:type])
+    replacements
+  end
+
+  def modifiers?(match)
+    !match[:flags].empty? || !match[:width].nil? || !match[:precision].nil?
+  end
+end

data/lib/evilution/mutator/operator/forwarded_argument_drop.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Stop forwarding one part of the arguments a method passes through unnamed:
+# `target.call(*, **, &)` becomes `target.call(**, &)`, and so on for each part.
+#
+# A survivor means that part never reaches an assertion — nothing checks that
+# the positional arguments, the keywords or the block arrive at the other end.
+#
+# Two spellings are handled. Anonymous `*` and `**` are dropped from the
+# argument list they are written in. A `...` cannot be split where it stands,
+# because `*`, `**` and `&` may not be written under a `...` signature, so the
+# signature is spelled out as `(*, **, &)` along with every use, and one use
+# loses one part: `def f(...) = g(...)` becomes `def f(*, **, &) = g(**, &)`.
+#
+# Named splats are left to SplatOperator and KeywordArgument, and an anonymous
+# `&` written on its own to BlockPassRemoval.
+class Evilution::Mutator::Operator::ForwardedArgumentDrop < Evilution::Mutator::Base
+  PARTS = ["*", "**", "&"].freeze
+  ALL_PARTS = PARTS.join(", ").freeze
+
+  def visit_def_node(node)
+    drop_forwarded_parts(node)
+    super
+  end
+
+  def visit_call_node(node)
+    drop_anonymous_arguments(node)
+    super
+  end
+
+  def visit_super_node(node)
+    drop_anonymous_arguments(node)
+    super
+  end
+
+  def visit_yield_node(node)
+    drop_anonymous_arguments(node)
+    super
+  end
+
+  private
+
+  def drop_anonymous_arguments(node)
+    return if node.arguments.nil?
+
+    items = argument_items(node.arguments)
+    # Dropping the only argument leaves an empty list, which is the mutant
+    # ArgumentListRemoval already emits.
+    return if items.length < 2
+
+    items.each_index do |index|
+      emit_argument_drop(node, items, index) if anonymous?(items[index])
+    end
+  end
+
+  # Keywords sit together in one KeywordHashNode, `**` among them; they are
+  # listed individually so each can be dropped on its own.
+  def argument_items(arguments)
+    arguments.arguments.flat_map do |argument|
+      argument.is_a?(Prism::KeywordHashNode) ? argument.elements : [argument]
+    end
+  end
+
+  def anonymous?(item)
+    case item
+    when Prism::SplatNode then item.expression.nil?
+    when Prism::AssocSplatNode then item.value.nil?
+    else false
+    end
+  end
+
+  def emit_argument_drop(node, items, index)
+    remaining = items.map(&:slice)
+    remaining.delete_at(index)
+    location = node.arguments.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: remaining.join(", "),
+      node: node
+    )
+  end
+
+  def drop_forwarded_parts(node)
+    return if node.body.nil?
+
+    uses = forwarding_uses(node.body)
+    uses.each do |target|
+      PARTS.each { |part| emit_part_drop(node, uses, target, part) }
+    end
+  end
+
+  # Every `...` the method forwards. A method defined in the body is not
+  # searched: its `...` forwards that method's own arguments.
+  def forwarding_uses(node)
+    return [] if node.is_a?(Prism::DefNode)
+    return [node] if node.is_a?(Prism::ForwardingArgumentsNode)
+
+    node.compact_child_nodes.flat_map { |child| forwarding_uses(child) }
+  end
+
+  # A `...` can only be forwarded by the method that declares it, so a use
+  # found in the body means the signature ends in the matching parameter.
+  def emit_part_drop(node, uses, target, part)
+    edits = uses.map do |use|
+      [use.location, use.equal?(target) ? (PARTS - [part]).join(", ") : ALL_PARTS]
+    end
+    edits << [node.parameters.keyword_rest.location, ALL_PARTS]
+
+    emit_rewrite(node, edits.sort_by { |location, _text| location.start_offset })
+  end
+
+  # The signature and the uses are apart in the source, while a mutation
+  # replaces one contiguous range, so the range runs from the first edit to
+  # the last and is rewritten with every edit applied.
+  def emit_rewrite(node, edits)
+    start_offset = edits.first.first.start_offset
+    length = edits.last.first.end_offset - start_offset
+
+    add_mutation(
+      offset: start_offset,
+      length: length,
+      replacement: apply_edits(byteslice_source(start_offset, length), edits, start_offset),
+      node: node
+    )
+  end
+
+  # Applied last to first, so an edit never shifts the offsets of those still
+  # to come.
+  def apply_edits(text, edits, base_offset)
+    edits.reverse_each do |location, replacement|
+      text = text.byteslice(0, location.start_offset - base_offset) +
+             replacement +
+             text.byteslice((location.end_offset - base_offset)..)
+    end
+
+    text
+  end
+end

data/lib/evilution/mutator/operator/inequality_to_negated_identity.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Rewrite an inequality with stricter comparisons: `a != b` becomes
+# `!a.eql?(b)` and `!a.equal?(b)`.
+#
+# `eql?` adds a type check (`1 != 1.0` is false, `!1.eql?(1.0)` is true) and
+# `equal?` compares identity (two equal strings or arrays are still
+# different objects). A survivor means no test separates value equality from
+# the stricter forms, so the comparison in use is never pinned down.
+#
+# Comparisons against nil, true, false or a symbol literal are skipped: those
+# are singletons, so all three forms always agree.
+class Evilution::Mutator::Operator::InequalityToNegatedIdentity < Evilution::Mutator::Base
+  SELECTORS = %i[eql? equal?].freeze
+  private_constant :SELECTORS
+
+  SINGLETON_LITERALS = [Prism::NilNode, Prism::TrueNode, Prism::FalseNode, Prism::SymbolNode].freeze
+  private_constant :SINGLETON_LITERALS
+
+  def visit_call_node(node)
+    rewrite(node) if node.name == :!=
+    super
+  end
+
+  private
+
+  def rewrite(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [argument]]
+    return if [node.receiver, argument].any? { |operand| singleton_literal?(operand) }
+
+    left = receiver_source(node.receiver)
+    SELECTORS.each do |selector|
+      add_mutation(offset: node.start_offset, length: node.location.length,
+                   replacement: "!#{left}.#{selector}(#{source_of(argument)})", node: node)
+    end
+  end
+
+  def singleton_literal?(operand)
+    SINGLETON_LITERALS.any? { |type| operand.is_a?(type) }
+  end
+end

data/lib/evilution/mutator/operator/integer_division_to_fdiv.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Turn a division into `fdiv`: `a / b` becomes `a.fdiv(b)`.
+#
+# Between integers `/` drops the remainder while `fdiv` keeps it as a float,
+# and for exact types such as Rational or BigDecimal `fdiv` falls back to
+# Float. A survivor means no example divides values that leave a remainder,
+# or none checks what happens to it.
+#
+# A float literal on either side is skipped: float division and `fdiv` give
+# the same answer, so the mutant would change nothing.
+class Evilution::Mutator::Operator::IntegerDivisionToFdiv < Evilution::Mutator::Base
+  # Receivers that `.fdiv` can follow directly. Anything else is an operator
+  # expression, which `.fdiv` would bind into, so it is grouped first.
+  SIMPLE_RECEIVER_TYPES = [
+    Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode,
+    Prism::GlobalVariableReadNode, Prism::ConstantReadNode, Prism::ConstantPathNode,
+    Prism::IntegerNode, Prism::ParenthesesNode, Prism::SelfNode
+  ].freeze
+
+  # A method name, as opposed to an operator such as `*` or `-@`.
+  METHOD_NAME = /\A[a-zA-Z_]\w*[?!]?\z/
+
+  def visit_call_node(node)
+    replace_division(node) if division?(node)
+    super
+  end
+
+  private
+
+  # The explicit form (`a./(b)`) is left alone: it is rare, and rewriting it
+  # gains nothing over the operator form. The operator form always has a
+  # receiver and exactly one divisor.
+  def division?(node)
+    return false unless node.name == :/ && node.call_operator_loc.nil?
+
+    [node.receiver, *node.arguments.arguments].none?(Prism::FloatNode)
+  end
+
+  def replace_division(node)
+    divisor = node.arguments.arguments.first
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "#{receiver_text(node.receiver)}.fdiv(#{divisor.slice})",
+      node: node
+    )
+  end
+
+  def receiver_text(receiver)
+    simple_receiver?(receiver) ? receiver.slice : "(#{receiver.slice})"
+  end
+
+  def simple_receiver?(receiver)
+    return true if SIMPLE_RECEIVER_TYPES.include?(receiver.class)
+
+    receiver.is_a?(Prism::CallNode) && receiver.name.to_s.match?(METHOD_NAME)
+  end
+end

data/lib/evilution/mutator/operator/keyword_argument.rb

@@ -8,7 +8,7 @@ class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
     if params
       mutate_optional_keyword_defaults(params)
       mutate_optional_keyword_removal(params)
-      mutate_keyword_rest_removal(params)
+      mutate_keyword_rest_removal(node)
     end
 
     super
@@ -51,9 +51,11 @@ class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
     end
   end
 
-  def mutate_keyword_rest_removal(params)
+  def mutate_keyword_rest_removal(node)
+    params = node.parameters
     kr = params.keyword_rest
     return unless kr.is_a?(Prism::KeywordRestParameterNode)
+    return if anonymous_rest_used?(node.body)
 
     all_params = collect_all_params(params)
     if all_params.length < 2
@@ -63,6 +65,27 @@ class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
     end
   end
 
+  # An anonymous `**` in the body (`bar(**)`, `{ ** }`) only parses while the
+  # signature declares one, so removing it there would leave the body
+  # unparseable. Finding one also tells the rest is anonymous: Ruby rejects it
+  # next to a named rest. A named rest is safe to remove: without it the body
+  # reads an undefined name, which parses and fails at runtime.
+  def anonymous_rest_used?(body)
+    return false if body.nil?
+
+    uses_anonymous_rest?(body)
+  end
+
+  # A nested def is not searched: an anonymous `**` inside it belongs to that
+  # method's own signature. Blocks and lambdas share the enclosing method's
+  # parameters, so they are.
+  def uses_anonymous_rest?(node)
+    return false if node.is_a?(Prism::DefNode)
+    return true if node.is_a?(Prism::AssocSplatNode) && node.value.nil?
+
+    node.compact_child_nodes.any? { |child| uses_anonymous_rest?(child) }
+  end
+
   def emit_remove_only_kr(kr)
     add_mutation(
       offset: kr.location.start_offset,

data/lib/evilution/mutator/operator/keyword_argument_removal.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Drop one keyword argument at a call site: `build(name: "x", size: 2)`
+# becomes `build(size: 2)` and `build(name: "x")`. Applies to any argument
+# list — calls, `super` and `yield`.
+#
+# A survivor means the callee never consumes that keyword, or its default
+# happens to match. argument_removal and argument_nil_substitution skip
+# keyword arguments entirely.
+#
+# Only `key: value` pairs are dropped; a `**opts` double splat stays, though
+# it still counts as a neighbour when removing the separator. A lone keyword
+# that is the whole argument list is left to argument_list_removal.
+class Evilution::Mutator::Operator::KeywordArgumentRemoval < Evilution::Mutator::Base
+  def visit_arguments_node(node)
+    node.arguments.each_with_index do |argument, index|
+      next unless argument.is_a?(Prism::KeywordHashNode)
+
+      drop_keywords(argument, index.zero? ? nil : node.arguments[index - 1])
+    end
+
+    super
+  end
+
+  private
+
+  def drop_keywords(hash, previous_argument)
+    elements = hash.elements
+    return if elements.length == 1 && previous_argument.nil?
+
+    elements.each_with_index do |element, index|
+      next unless element.is_a?(Prism::AssocNode)
+
+      drop_element(element, elements[index + 1], index.zero? ? previous_argument : elements[index - 1])
+    end
+  end
+
+  # Cut from the element to the next one, or — for the last element — from
+  # the end of whatever precedes it, so the separating comma goes too.
+  def drop_element(element, following, preceding)
+    start, finish = following ? [element.start_offset, following.start_offset] : [preceding.end_offset, element.end_offset]
+
+    add_mutation(offset: start, length: finish - start, replacement: "", node: element, skip_unparseable: true)
+  end
+end