evilution 1.2.0 → 1.4.0

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace an `Array()` coercion with an array literal: `Array(value)` becomes
+# `[value]`, and the same for `Kernel.Array(value)` / `Kernel::Array(value)`.
+#
+# The two agree only on a plain scalar. `Array(nil)` is `[]` where `[nil]`
+# is not, an array or hash is converted rather than wrapped, and anything
+# responding to `to_ary` / `to_a` is unpacked. A survivor means no test
+# passes nil or a collection through the coercion.
+class Evilution::Mutator::Operator::ArrayCoercionToLiteral < Evilution::Mutator::Base
+  def visit_call_node(node)
+    rewrite(node) if node.name == :Array && kernel_receiver?(node.receiver) && node.block.nil?
+    super
+  end
+
+  private
+
+  def rewrite(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [argument]]
+    return if argument.is_a?(Prism::SplatNode)
+
+    replace_span(node: node, target: node, replacement: "[#{source_of(argument)}]")
+  end
+
+  def kernel_receiver?(receiver)
+    case receiver
+    when nil then true
+    when Prism::ConstantReadNode then receiver.name == :Kernel
+    when Prism::ConstantPathNode then receiver.parent.nil? && receiver.name == :Kernel
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace an attribute or index write with the matching read: `a.foo = b`
+# becomes `a.foo`, `a[i] = b` becomes `a[i]`.
+#
+# A survivor means nothing observes the write. Only positions
+# statement_deletion does not reach are mutated: a write that is one of
+# several statements in a body is already deleted there, and turning it into
+# a read differs from that only by the reader call.
+class Evilution::Mutator::Operator::AttributeWriteToRead < Evilution::Mutator::Base
+  def call(subject, **)
+    @deletable_statements = Set.new
+    super
+  end
+
+  def visit_statements_node(node)
+    @deletable_statements.merge(node.body) if node.body.length > 1
+    super
+  end
+
+  def visit_call_node(node)
+    mutate_to_read(node) if node.attribute_write? && !@deletable_statements.include?(node)
+    super
+  end
+
+  private
+
+  def mutate_to_read(node)
+    read_length = node.message_loc.end_offset - node.start_offset
+    replace_span(node: node, target: node, replacement: byteslice_source(node.start_offset, read_length))
+  end
+end

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

@@ -3,10 +3,18 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::BangMethod < Evilution::Mutator::Base
+  # Methods that have an in-place bang twin on at least one of String, Array,
+  # Hash or Set (the same set on every supported Ruby, 3.3+), plus `update` /
+  # `save` for ActiveRecord. String's `succ` / `next` are left out: those
+  # names are far more often called on Integer, which has no bang twin.
   KNOWN_BANG_PAIRS = %i[
-    sort map collect select reject uniq compact flatten
-    shuffle reverse slice gsub sub strip chomp chop squeeze
-    delete encode merge update save
+    sort sort_by map collect select filter reject uniq compact flatten
+    shuffle reverse rotate slice
+    gsub sub tr tr_s strip lstrip rstrip chomp chop squeeze delete
+    delete_prefix delete_suffix capitalize downcase upcase swapcase
+    scrub encode unicode_normalize
+    merge transform_keys transform_values
+    update save
   ].to_set.freeze
 
   def visit_call_node(node)

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace an arithmetic or bitwise expression with one of its operands:
+# `a + b` becomes `a` and `b`.
+#
+# A survivor means one operand never affects the tested result. Comparisons
+# are left to the comparison and conditional operators.
+#
+# An operand is not promoted when the other side is the operator's integer
+# identity — `a + 0` or `a * 1` already equals `a`. A float literal does not
+# count (`a + 0.0` turns an Integer into a Float), and neither do shifts,
+# since `<<` also appends. A binary send in void statement position is left
+# to statement_deletion.
+class Evilution::Mutator::Operator::BinaryOperandPromotion < Evilution::Mutator::Base
+  OPERATORS = %i[+ - * / % ** & | ^ << >>].to_set.freeze
+  private_constant :OPERATORS
+
+  # The literal on the right that makes `left <op> literal` equal `left`.
+  RIGHT_IDENTITIES = { :+ => 0, :- => 0, :* => 1, :/ => 1, :** => 1, :| => 0, :^ => 0 }.freeze
+  private_constant :RIGHT_IDENTITIES
+
+  # The literal on the left that makes `literal <op> right` equal `right`.
+  LEFT_IDENTITIES = { :+ => 0, :* => 1, :| => 0, :^ => 0 }.freeze
+  private_constant :LEFT_IDENTITIES
+
+  def call(subject, **)
+    @void_statements = Set.new
+    super
+  end
+
+  def visit_statements_node(node)
+    @void_statements.merge(node.body[...-1])
+    super
+  end
+
+  def visit_call_node(node)
+    right = right_operand(node)
+    promote_operands(node, node.receiver, right) if right && !@void_statements.include?(node)
+    super
+  end
+
+  private
+
+  # The single argument of a binary operator send; nil otherwise. An operator
+  # send always has a receiver — `+b` without one is the unary `+@`.
+  def right_operand(node)
+    return unless OPERATORS.include?(node.name)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [right]]
+
+    right
+  end
+
+  def promote_operands(node, left, right)
+    promote_child(node, left) unless integer_literal?(right, RIGHT_IDENTITIES[node.name])
+    promote_child(node, right) unless integer_literal?(left, LEFT_IDENTITIES[node.name])
+  end
+
+  def integer_literal?(operand, value)
+    operand.is_a?(Prism::IntegerNode) && operand.value == value
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a call with its parameter-less block's body, run once in place:
+# `Base.transaction { account.save! }` becomes `account.save!`, and
+# `3.times { retry_call }` becomes `retry_call`. A multi-statement body is
+# grouped in parentheses so it still evaluates to its last statement where
+# the call's value is used.
+#
+# A survivor means the wrapping call is never observed: a transaction whose
+# rollback no test triggers, a lock nothing contends for, an iteration count
+# nothing checks.
+#
+# Blocks with parameters (including `_1` / `it` and block-locals) are
+# skipped — the unwrapped body would reference a variable that no longer
+# exists; explicitly empty pipes `{ || ... }` count as parameter-less. So are
+# bodies with a rescue / ensure clause, and bodies using `break` / `next` /
+# `redo`, which do not parse outside a block and are dropped by the parse
+# guard.
+class Evilution::Mutator::Operator::BlockBodyPromotion < Evilution::Mutator::Base
+  def visit_call_node(node)
+    block = node.block
+    unwrap(node, block.body) if block.is_a?(Prism::BlockNode) && parameterless?(block.parameters)
+    super
+  end
+
+  private
+
+  # No parameters at all, or explicitly empty pipes `{ || ... }`. Block-local
+  # variables (`{ |;tmp| ... }`) count as parameters: unwrapping would turn
+  # them into method locals.
+  def parameterless?(parameters)
+    parameters.nil? ||
+      (parameters.is_a?(Prism::BlockParametersNode) && parameters.parameters.nil? && parameters.locals.empty?)
+  end
+
+  def unwrap(node, body)
+    return unless body.is_a?(Prism::StatementsNode)
+
+    statements = body.body
+    replacement = statements.length == 1 ? source_of(statements.first) : "(#{source_of(body)})"
+    replace_span(node: node, target: node, replacement: replacement)
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a block's body with `nil`: `items.map { |item| item * 2 }` becomes
+# `items.map { |item| nil }`. Unlike block_removal, the iteration itself
+# stays, so a survivor means the block runs but nothing observes what it
+# does.
+#
+# A `do ... rescue ... end` block keeps its rescue / ensure clauses; only
+# the main statements become nil.
+#
+# Blocks that are themselves the loop are skipped — `loop { }` and an
+# endless `cycle { }` or `cycle(nil) { }` — since with a nil body nothing
+# breaks out and the mutant would hang until the per-mutation timeout (see
+# EV-170m.7).
+class Evilution::Mutator::Operator::BlockBodyToNil < Evilution::Mutator::Base
+  def visit_call_node(node)
+    block = node.block
+    empty_body(node, block) if block.is_a?(Prism::BlockNode) && !endless_iteration?(node)
+    super
+  end
+
+  private
+
+  def empty_body(node, block)
+    body = block.body
+    statements = body.is_a?(Prism::BeginNode) ? body.statements : body
+    mutate_to_nil(node, target: statements)
+  end
+
+  def endless_iteration?(node)
+    case node.name
+    when :loop then kernel_receiver?(node.receiver)
+    when :cycle then endless_count?(node.arguments)
+    end
+  end
+
+  # `loop`, `Kernel.loop` or `::Kernel.loop` — not a namespaced `Acme::Kernel`.
+  def kernel_receiver?(receiver)
+    case receiver
+    when nil then true
+    when Prism::ConstantReadNode then receiver.name == :Kernel
+    when Prism::ConstantPathNode then receiver.parent.nil? && receiver.name == :Kernel
+    end
+  end
+
+  # `cycle` and `cycle(nil)` both repeat forever.
+  def endless_count?(arguments)
+    arguments.nil? || (arguments in Prism::ArgumentsNode[arguments: [Prism::NilNode]])
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a block's body with a bare `raise`: `items.map { |item| item * 2 }`
+# becomes `items.map { |item| raise }`.
+#
+# A survivor means no test ever invokes the block — every collection it
+# iterates is empty, or the callback is never called. The raise ends the
+# block on its first call, so unlike block_body_to_nil a `loop { }` is safe
+# here.
+#
+# A block whose body has a `rescue` clause is skipped: that clause would
+# catch the raise, and the mutant would exercise the rescue path instead of
+# the invocation. An `ensure` clause does not swallow it and stays.
+class Evilution::Mutator::Operator::BlockBodyToRaise < Evilution::Mutator::Base
+  def visit_call_node(node)
+    block = node.block
+    raise_in_body(node, block.body) if block.is_a?(Prism::BlockNode)
+    super
+  end
+
+  private
+
+  def raise_in_body(node, body)
+    if body.is_a?(Prism::BeginNode)
+      return if body.rescue_clause
+
+      body = body.statements
+    end
+
+    replace_span(node: node, target: body, replacement: "raise")
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a method call with `nil`: `user.name` becomes `nil`, and the same
+# for implicit-self calls, operator calls and calls carrying a block.
+#
+# The broadest value-level probe on a call site. The survivor it targets is a
+# call whose result is never asserted — the test runs the code but checks
+# nothing that depends on what the call returned.
+#
+# Three positions are skipped as noise. A call in void statement position
+# (every statement of a body except the last) has no value to replace;
+# deleting it is statement_deletion's job. A call used as the receiver of
+# another call turns into `nil.foo`, a NoMethodError any test that reaches it
+# kills; the outer call is nil-ified instead. An attribute or index write
+# (`a.b = c`, `a[i] = c`) is a side effect, not a value.
+class Evilution::Mutator::Operator::CallToNil < Evilution::Mutator::Base
+  def call(subject, **)
+    @skipped_calls = Set.new
+    super
+  end
+
+  def visit_statements_node(node)
+    @skipped_calls.merge(node.body[...-1])
+    super
+  end
+
+  def visit_call_node(node)
+    @skipped_calls.add(node.receiver)
+    mutate_to_nil(node) unless @skipped_calls.include?(node) || node.attribute_write?
+    super
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a conversion with an empty value of its target type: `value.to_a`
+# becomes `[]`, `value.to_h` becomes `{}`, `value.to_s` becomes `""`, and the
+# same for the implicit `to_ary` / `to_hash` / `to_str` forms.
+#
+# The type stays right, so a survivor means tests check what kind of value
+# comes out but never what it contains.
+#
+# An empty hash that is the first argument of an unparenthesized call,
+# `yield` or `super` is written `({})`: bare `{}` there would be parsed as a
+# block. A nil receiver is skipped — its conversion is already empty.
+class Evilution::Mutator::Operator::CoercionEmptying < Evilution::Mutator::Base
+  EMPTY_VALUES = {
+    to_a: "[]", to_ary: "[]",
+    to_h: "{}", to_hash: "{}",
+    to_s: '""', to_str: '""'
+  }.freeze
+  private_constant :EMPTY_VALUES
+
+  def call(subject, **)
+    @bare_first_arguments = Set.new
+    super
+  end
+
+  def visit_call_node(node)
+    note_bare_first_argument(node, node.opening_loc)
+    empty(node) if emptiable?(node)
+    super
+  end
+
+  def visit_yield_node(node)
+    note_bare_first_argument(node, node.lparen_loc)
+    super
+  end
+
+  def visit_super_node(node)
+    note_bare_first_argument(node, node.lparen_loc)
+    super
+  end
+
+  private
+
+  def note_bare_first_argument(node, opening)
+    @bare_first_arguments.add(node.arguments.arguments.first) if opening.nil? && node.arguments
+  end
+
+  def emptiable?(node)
+    EMPTY_VALUES.key?(node.name) && node.receiver && !node.receiver.is_a?(Prism::NilNode) &&
+      node.arguments.nil? && node.block.nil?
+  end
+
+  def empty(node)
+    value = EMPTY_VALUES.fetch(node.name)
+    value = "(#{value})" if value == "{}" && @bare_first_arguments.include?(node)
+    replace_span(node: node, target: node, replacement: value)
+  end
+end

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

@@ -12,10 +12,10 @@ class Evilution::Mutator::Operator::CollectionReplacement < Evilution::Mutator::
     collect: [:each],
     sort: [:sort_by],
     sort_by: [:sort],
-    find: [:detect],
-    detect: [:find],
-    any?: [:all?],
-    all?: [:any?],
+    find: %i[detect first last],
+    detect: %i[find first last],
+    any?: %i[all? empty? none?],
+    all?: %i[any? none?],
     count: [:length],
     length: [:count],
     pop: [:shift],
@@ -30,10 +30,10 @@ class Evilution::Mutator::Operator::CollectionReplacement < Evilution::Mutator::
     grep_v: [:grep],
     take: [:drop],
     drop: [:take],
-    min: [:max],
-    max: [:min],
-    min_by: [:max_by],
-    max_by: [:min_by],
+    min: %i[max first last],
+    max: %i[min first last],
+    min_by: %i[max_by first last],
+    max_by: %i[min_by first last],
     compact: [:flatten],
     flatten: [:compact],
     zip: [:product],
@@ -41,7 +41,17 @@ class Evilution::Mutator::Operator::CollectionReplacement < Evilution::Mutator::
     first: [:last],
     last: [:first],
     keys: [:values],
-    values: [:keys]
+    values: [:keys],
+    sample: %i[first last],
+    fetch: [:key?],
+    at: %i[fetch key?],
+    delete_if: [:reject],
+    keep_if: [:select],
+    filter_map: [:map],
+    chunk: [:each],
+    chunk_while: [:each],
+    each_with_index: [:each],
+    slice_when: [:each]
   }.freeze
 
   def visit_call_node(node)

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Swap the operands of a spaceship comparison: `a <=> b` becomes `b <=> a`.
+#
+# The result changes sign, so a sort block sorts the other way and a custom
+# `<=>` orders the other way round. A survivor means no example asserts the
+# direction of the ordering.
+#
+# Two-argument ordering methods (`between?`, `clamp`) are reversed by
+# ArgumentOrderPermutation. Identical operands are not swapped, since that
+# would reproduce the original comparison, and neither is a safe-navigation
+# call, where moving the other operand into the receiver's place changes what
+# may be nil.
+class Evilution::Mutator::Operator::ComparisonOperandSwap < Evilution::Mutator::Base
+  def visit_call_node(node)
+    swap_operands(node) if spaceship?(node)
+    super
+  end
+
+  private
+
+  # Ruby has no receiverless spaceship, but the explicit form can be written
+  # with no argument or several (`a.<=>`, `a.<=>(b, c)`); those have no pair
+  # of operands to swap.
+  def spaceship?(node)
+    return false unless node.name == :<=> && !node.safe_navigation?
+    return false if node.arguments.nil?
+
+    node.arguments.arguments.length == 1
+  end
+
+  # Whatever sits between the operands — the operator and its spacing, or
+  # `.<=>(` in the explicit form — stays in place.
+  def swap_operands(node)
+    left = node.receiver
+    right = node.arguments.arguments.first
+    return if left.slice == right.slice
+
+    start_offset = left.location.start_offset
+
+    add_mutation(
+      offset: start_offset,
+      length: right.location.end_offset - start_offset,
+      replacement: "#{right.slice}#{source_between(left, right)}#{left.slice}",
+      node: node
+    )
+  end
+
+  def source_between(left, right)
+    byteslice_source(left.location.end_offset, right.location.start_offset - left.location.end_offset)
+  end
+end

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

@@ -12,22 +12,47 @@ class Evilution::Mutator::Operator::ComparisonReplacement < Evilution::Mutator::
     :!= => [:==]
   }.freeze
 
+  # Operators rewritten into a method call, since the method cannot be
+  # swapped in as an operator (`a eql? b` does not parse). Ordering
+  # comparisons collapse to the stricter equalities — `a < b` becomes
+  # `a.eql?(b)` and `a.equal?(b)` — and `a =~ b` becomes `a.match?(b)`,
+  # which returns a boolean and leaves `$~` / `$1` unset.
+  EQUALITY_METHODS = %i[eql? equal?].freeze
+  private_constant :EQUALITY_METHODS
+
+  METHOD_REPLACEMENTS = {
+    :< => EQUALITY_METHODS,
+    :<= => EQUALITY_METHODS,
+    :> => EQUALITY_METHODS,
+    :>= => EQUALITY_METHODS,
+    :=~ => [:match?]
+  }.freeze
+  private_constant :METHOD_REPLACEMENTS
+
   def visit_call_node(node)
-    replacements = REPLACEMENTS[node.name]
-    return super unless replacements
+    replace_operator(node)
+    replace_with_methods(node)
+    super
+  end
+
+  private
 
+  def replace_operator(node)
     loc = node.message_loc
-    return super unless loc
-
-    replacements.each do |replacement|
-      add_mutation(
-        offset: loc.start_offset,
-        length: loc.length,
-        replacement: replacement.to_s,
-        node: node
-      )
+
+    REPLACEMENTS.fetch(node.name, []).each do |replacement|
+      add_mutation(offset: loc.start_offset, length: loc.length, replacement: replacement.to_s, node: node)
     end
+  end
 
-    super
+  def replace_with_methods(node)
+    methods = METHOD_REPLACEMENTS[node.name]
+    return unless methods && (node.arguments in Prism::ArgumentsNode[arguments: [argument]])
+
+    left = receiver_source(node.receiver)
+    methods.each do |method|
+      add_mutation(offset: node.start_offset, length: node.location.length,
+                   replacement: "#{left}.#{method}(#{source_of(argument)})", node: node)
+    end
   end
 end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Resolve a dynamic constant lookup with a literal name into a constant path:
+# `Registry.const_get(:Handler)` becomes `Registry::Handler`. A literal
+# inherit flag is dropped; a receiverless call resolves against `self`.
+#
+# Both forms find the same own, inherited and mixed-in constants and raise the
+# same NameError for a missing one. They differ on top-level constants (found
+# by `const_get` through Object, rejected by `::`), on private constants
+# (returned by `const_get` only) and with `inherit = false` (ancestors skipped
+# by `const_get`, searched by `::`). A survivor means none of those paths is
+# exercised, so the dynamic lookup may not be needed.
+#
+# Safe navigation is skipped: a constant path has no nil-safe form.
+class Evilution::Mutator::Operator::ConstGetToConstantPath < Evilution::Mutator::Base
+  CONSTANT_NAME = /\A[A-Z]\w*\z/
+  private_constant :CONSTANT_NAME
+
+  # `nil` behaves like `false`.
+  INHERIT_FLAGS = [Prism::TrueNode, Prism::FalseNode, Prism::NilNode].freeze
+  private_constant :INHERIT_FLAGS
+
+  def visit_call_node(node)
+    rewrite(node) if node.name == :const_get && node.block.nil? && !node.safe_navigation?
+    super
+  end
+
+  private
+
+  def rewrite(node)
+    name = constant_name(node)
+    return if name.nil?
+
+    receiver = node.receiver ? source_of(node.receiver) : "self"
+    add_mutation(offset: node.start_offset, length: node.location.length, replacement: "#{receiver}::#{name}", node: node)
+  end
+
+  def constant_name(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [Prism::SymbolNode => symbol, *flags]]
+    return unless flags.empty? || literal_inherit_flag?(flags)
+
+    symbol.unescaped if symbol.unescaped.match?(CONSTANT_NAME)
+  end
+
+  def literal_inherit_flag?(flags)
+    flags.length == 1 && INHERIT_FLAGS.any? { |type| flags.first.is_a?(type) }
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+require_relative "../../ast/value_object_definition"
+
+# Mutate the member list of a value-object definition: `Data.define(:a, :b)`
+# and `Struct.new(:a, :b)` lose one member at a time, and have each adjacent
+# pair of members swapped.
+#
+# A surviving drop means no example reads or sets that member. A surviving swap
+# means the type is built positionally somewhere the order is never asserted,
+# so two members could trade values unnoticed.
+#
+# Definitions outside any method — assigned to a constant, or the superclass
+# of a class — are constant subjects of their own, and this operator mutates
+# them there. A constant subject is the definition alone: definitions nested
+# in its block are subjects of their own too.
+class Evilution::Mutator::Operator::DataStructMember < Evilution::Mutator::Base
+  # Arguments whose position and meaning are known: members are symbols, a
+  # string is the class name `Struct.new("Name", ...)` takes first, and the
+  # keyword hash carries `keyword_init:`. Anything else (a splat, a variable)
+  # hides the member list, so the definition is left alone.
+  KNOWN_ARGUMENT_TYPES = [Prism::SymbolNode, Prism::StringNode, Prism::KeywordHashNode].freeze
+
+  def self.subject_kinds
+    %i[method constant]
+  end
+
+  # A constant subject's node is the definition itself, so the visit stops
+  # there rather than reaching definitions nested in its block.
+  def visit_call_node(node)
+    mutate_members(node) if Evilution::AST::ValueObjectDefinition.match?(node)
+    super unless @subject.kind == :constant
+  end
+
+  private
+
+  def mutate_members(node)
+    arguments = node.arguments ? node.arguments.arguments : []
+    members = member_indexes(arguments)
+    # A lone member has no neighbour to swap with, and dropping it would leave
+    # `Struct.new()`, which raises on Rubies that require at least one member.
+    return if members.length < 2
+
+    slices = arguments.map(&:slice)
+    members.each { |index| emit_member_drop(node, slices, index) }
+    members.each_cons(2) { |left, right| emit_member_swap(node, slices, left, right) }
+  end
+
+  def member_indexes(arguments)
+    return [] unless arguments.all? { |argument| KNOWN_ARGUMENT_TYPES.include?(argument.class) }
+
+    arguments.each_index.select { |index| arguments[index].is_a?(Prism::SymbolNode) }
+  end
+
+  def emit_member_drop(node, slices, index)
+    remaining = slices.dup
+    remaining.delete_at(index)
+    replace_arguments(node, remaining)
+  end
+
+  def emit_member_swap(node, slices, left, right)
+    return if slices[left] == slices[right]
+
+    swapped = slices.dup
+    swapped[left], swapped[right] = swapped[right], swapped[left]
+    replace_arguments(node, swapped)
+  end
+
+  def replace_arguments(node, slices)
+    location = node.arguments.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: slices.join(", "),
+      node: node
+    )
+  end
+end