evilution 1.3.0 → 1.5.0

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

@@ -4,39 +4,57 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::SplatOperator < Evilution::Mutator::Base
   def visit_splat_node(node)
-    mutate_remove_splat(node) if node.expression
+    mutate_remove_splat(node) if node.expression && !exempt_splats.include?(node)
 
     super
   end
 
+  # Inside a hash literal `**opts` merges a hash in; a bare `opts` is not an
+  # element (`{ opts }` is a syntax error), so these splats are skipped.
   def visit_hash_node(node)
-    node.elements.each { |el| hash_elements.add(el) }
+    exempt_splats.merge(node.elements.grep(Prism::AssocSplatNode))
+    super
+  end
+
+  # The rest of a pattern binds what is left over; it is not a splat in a
+  # call or a literal, so these splats are skipped. Dropping `**` from
+  # `{ key:, **opts }` is a syntax error. Dropping `*` from `[a, *rest]`
+  # parses, but it narrows the pattern to a fixed length. That mutant is
+  # deliberately not emitted, and the pattern operators keep a binding rest
+  # (`*rest`, `**opts`) as written. The rest of a multiple assignment
+  # (`a, *b = x`) is still mutated: `a, b = x` parses and changes what `b`
+  # binds.
+  def visit_hash_pattern_node(node)
+    exempt_splats.add(node.rest) if node.rest
+    super
+  end
+
+  def visit_array_pattern_node(node)
+    exempt_splats.add(node.rest) if node.rest
+    super
+  end
+
+  def visit_find_pattern_node(node)
+    exempt_splats.add(node.left)
+    exempt_splats.add(node.right)
     super
   end
 
   # KeywordHashNode wraps call-arg kwargs + `**splat`. When an explicit
-  # `k: v` precedes a `**opts` splat in the same call, demoting `**opts` to
-  # bare `opts` puts a positional after a keyword and Ruby rejects it
-  # (`bar(k: v, opts)` is a syntax error). Mark such splats so
-  # `visit_assoc_splat_node` skips them. Splats that come BEFORE any kwarg
-  # (`bar(**opts, k: v)`) are still safe — positional-before-keyword is fine.
+  # `k: v` or another `**splat` precedes a `**opts` splat in the same call,
+  # demoting `**opts` to bare `opts` puts a positional after a keyword
+  # argument and Ruby rejects it (`bar(k: v, opts)` and `bar(**a, opts)` are
+  # syntax errors), so such splats are skipped.
+  # A splat that comes first (`bar(**opts, k: v)`) is still safe —
+  # positional-before-keyword is fine.
   def visit_keyword_hash_node(node)
-    seen_kwarg = false
-    node.elements.each do |el|
-      if el.is_a?(Prism::AssocSplatNode) && seen_kwarg
-        kwarg_preceded_splats.add(el)
-      elsif el.is_a?(Prism::AssocNode)
-        seen_kwarg = true
-      end
-    end
-
+    exempt_splats.merge(node.elements.drop(1).grep(Prism::AssocSplatNode))
     super
   end
 
   def visit_assoc_splat_node(node)
     return super if node.value.nil?
-    return super if hash_elements.include?(node)
-    return super if kwarg_preceded_splats.include?(node)
+    return super if exempt_splats.include?(node)
 
     mutate_remove_double_splat(node)
 
@@ -45,12 +63,11 @@ class Evilution::Mutator::Operator::SplatOperator < Evilution::Mutator::Base
 
   private
 
-  def hash_elements
-    @hash_elements ||= Set.new.compare_by_identity
-  end
-
-  def kwarg_preceded_splats
-    @kwarg_preceded_splats ||= Set.new.compare_by_identity
+  # Splats that are left as written: removing the `*` or `**` would not
+  # parse, or would change what a pattern matches. Each visitor that fills
+  # the set says why.
+  def exempt_splats
+    @exempt_splats ||= Set.new.compare_by_identity
   end
 
   def mutate_remove_splat(node)

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Swap two adjacent commands: `charge(card); send_receipt(user)` becomes
+# `send_receipt(user); charge(card)`.
+#
+# A survivor means no example depends on the order the two side effects
+# happen in. Most pairs of statements could swap without anyone noticing, so
+# only pairs that are likely to matter are touched:
+#
+# - both statements are commands: they call a method, append, write an index,
+#   yield or call super. Assigning a local or instance variable stores a
+#   value, and statements without such effects swap freely.
+# - neither writes a variable the other reads or writes. Such a pair fails at
+#   once when swapped, which tests nothing about order.
+# - neither contains control flow (`return`, `break`, `next`, `redo`, `retry`,
+#   `raise`, `fail`), which would skip the other statement.
+# - the second is not the last statement of its body, which gives the body
+#   its value.
+# - neither contains a heredoc, whose body sits outside the statement's
+#   source range.
+# - they are not writes to different literal keys of the same receiver
+#   (`opts[:a] = 1; opts[:b] = 2`), which cannot affect each other.
+class Evilution::Mutator::Operator::StatementReorder < Evilution::Mutator::Base
+  CONTROL_FLOW_TYPES = [
+    Prism::ReturnNode, Prism::BreakNode, Prism::NextNode, Prism::RedoNode, Prism::RetryNode
+  ].freeze
+  RAISING_METHODS = %i[raise fail].freeze
+
+  # Calls that change their receiver without a method name: `a << b`, `a[k] = v`.
+  MUTATING_OPERATORS = %i[<< []=].freeze
+  METHOD_NAME = /\A[a-zA-Z_]/
+
+  EFFECT_TYPES = [Prism::YieldNode, Prism::SuperNode, Prism::ForwardingSuperNode].freeze
+
+  # Statements that store a value rather than act.
+  VALUE_WRITE_TYPES = [
+    Prism::LocalVariableWriteNode, Prism::LocalVariableOperatorWriteNode,
+    Prism::LocalVariableOrWriteNode, Prism::LocalVariableAndWriteNode,
+    Prism::InstanceVariableWriteNode, Prism::InstanceVariableOperatorWriteNode,
+    Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode
+  ].freeze
+
+  # Nodes that set a variable, and nodes that read one.
+  WRITE_TYPES = [
+    *VALUE_WRITE_TYPES, Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode,
+    Prism::ClassVariableWriteNode, Prism::ClassVariableOperatorWriteNode, Prism::ClassVariableOrWriteNode,
+    Prism::ClassVariableAndWriteNode, Prism::ClassVariableTargetNode,
+    Prism::GlobalVariableWriteNode, Prism::GlobalVariableOperatorWriteNode, Prism::GlobalVariableOrWriteNode,
+    Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableTargetNode
+  ].freeze
+  LITERAL_KEY_TYPES = [Prism::SymbolNode, Prism::StringNode, Prism::IntegerNode].freeze
+
+  READ_TYPES = [
+    Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode,
+    Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode
+  ].freeze
+
+  def visit_statements_node(node)
+    statements = node.body
+    # The last statement stays put, so pairs end one before it.
+    statements[0...-1].each_cons(2) do |first, second|
+      emit_swap(first, second) if swappable?(first, second)
+    end
+    super
+  end
+
+  private
+
+  def swappable?(first, second)
+    [first, second].all? { |statement| command?(statement) && !control_flow?(statement) && !heredoc?(statement) } &&
+      independent?(first, second) && !distinct_key_writes?(first, second)
+  end
+
+  def command?(statement)
+    return false if VALUE_WRITE_TYPES.include?(statement.class)
+
+    nodes_in(statement).any? { |node| effect?(node) }
+  end
+
+  def effect?(node)
+    return true if EFFECT_TYPES.include?(node.class)
+    return false unless node.is_a?(Prism::CallNode)
+
+    node.name.to_s.match?(METHOD_NAME) || MUTATING_OPERATORS.include?(node.name)
+  end
+
+  def control_flow?(statement)
+    nodes_in(statement).any? do |node|
+      CONTROL_FLOW_TYPES.include?(node.class) ||
+        (node.is_a?(Prism::CallNode) && node.receiver.nil? && RAISING_METHODS.include?(node.name))
+    end
+  end
+
+  def heredoc?(statement)
+    nodes_in(statement).any? do |node|
+      node.respond_to?(:heredoc?) && node.heredoc?
+    end
+  end
+
+  def distinct_key_writes?(first, second)
+    writes = [index_write(first), index_write(second)]
+    return false if writes.include?(nil)
+    return false unless writes.first.receiver.slice == writes.last.receiver.slice
+
+    distinct_literal_keys?(writes.map { |write| write.arguments.arguments.first })
+  end
+
+  def distinct_literal_keys?(keys)
+    keys.all? { |key| LITERAL_KEY_TYPES.include?(key.class) } && keys.first.slice != keys.last.slice
+  end
+
+  # `h[k] = v` on its own or under a modifier condition (`h[k] = v if v`).
+  def index_write(statement)
+    if statement.is_a?(Prism::IfNode) || statement.is_a?(Prism::UnlessNode)
+      body = statement.statements
+      statement = body.body.first if body && body.body.length == 1
+    end
+    statement if statement.is_a?(Prism::CallNode) && statement.name == :[]=
+  end
+
+  def independent?(first, second)
+    first_writes = names(first, WRITE_TYPES)
+    second_writes = names(second, WRITE_TYPES)
+
+    !first_writes.intersect?(names(second, READ_TYPES) | second_writes) &&
+      !second_writes.intersect?(names(first, READ_TYPES))
+  end
+
+  def names(statement, types)
+    nodes_in(statement).filter_map { |node| node.name if types.include?(node.class) }.to_set
+  end
+
+  def nodes_in(node)
+    [node, *node.compact_child_nodes.flat_map { |child| nodes_in(child) }]
+  end
+
+  # Whatever separates the two statements — a line break and indentation, or
+  # `; ` — stays between them.
+  def emit_swap(first, second)
+    start_offset = first.location.start_offset
+    end_offset = second.location.end_offset
+    separator = byteslice_source(first.location.end_offset, second.location.start_offset - first.location.end_offset)
+
+    add_mutation(
+      offset: start_offset,
+      length: end_offset - start_offset,
+      replacement: "#{second.slice}#{separator}#{first.slice}",
+      node: first
+    )
+  end
+end

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

@@ -3,6 +3,8 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::StringLiteral < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
   def initialize(skip_heredoc_literals: false, **rest)
     super(**rest)
     @skip_heredoc_literals = skip_heredoc_literals
@@ -32,6 +34,11 @@ class Evilution::Mutator::Operator::StringLiteral < Evilution::Mutator::Base
       return
     end
 
+    # The composed value as a whole, next to the chunks and interpolations
+    # inside it. A word of `%W[]` has no quotes of its own and is not a
+    # literal: `nil` there would be the word "nil".
+    emit_string_mutations(node) if node.opening_loc
+
     super
   end
 
@@ -59,11 +66,33 @@ class Evilution::Mutator::Operator::StringLiteral < Evilution::Mutator::Base
   end
 
   def visit_interpolated_x_string_node(node)
+    return if node.heredoc? && @skip_heredoc_literals
+
+    mutate_command_to_nil(node)
     visit_non_string_parts(node)
   end
 
+  def visit_x_string_node(node)
+    mutate_command_to_nil(node)
+    super
+  end
+
   private
 
+  # A command literal (`` `ls` ``, `%x(ls)`) is only ever replaced as a whole,
+  # by `nil`: the command then does not run. Its text is never rewritten, as
+  # a changed command would run for real wherever an example runs it.
+  def mutate_command_to_nil(node)
+    return if node.heredoc?
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
   def visit_non_string_parts(node)
     node.parts.each do |part|
       next if part.is_a?(Prism::StringNode)

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

@@ -3,7 +3,13 @@
 require "prism"
 
 require_relative "../operator"
+require_relative "../../ast/class_body"
 
+# Drop the superclass from a class definition: `class Admin < User` becomes
+# `class Admin`.
+#
+# The definition line belongs to no method, so the mutant is attributed to
+# the method anchoring the class body (see Evilution::AST::ClassBody).
 class Evilution::Mutator::Operator::SuperclassRemoval < Evilution::Mutator::Base
   def call(subject, filter: nil)
     @subject = subject
@@ -11,24 +17,22 @@ class Evilution::Mutator::Operator::SuperclassRemoval < Evilution::Mutator::Base
     @mutations = []
     @filter = filter
 
-    enclosing = find_target_class(subject)
-    return @mutations unless enclosing
-
-    offset, length = superclass_range(enclosing)
-    add_mutation(offset: offset, length: length, replacement: "", node: enclosing)
+    classes_with_superclass_for(subject).each do |class_node|
+      offset, length = superclass_range(class_node)
+      add_mutation(offset: offset, length: length, replacement: "", node: class_node)
+    end
 
     @mutations
   end
 
   private
 
-  def find_target_class(subject)
+  def classes_with_superclass_for(subject)
     tree = self.class.parsed_tree_for(subject.file_path, @file_source)
-    enclosing = find_enclosing_class(tree, subject.line_number)
-    return nil unless enclosing && enclosing.superclass
-    return nil unless find_first_method_line(enclosing) == subject.line_number
 
-    enclosing
+    Evilution::AST::ClassBody.anchored_at(tree, subject.line_number).map(&:node).select do |scope|
+      scope.is_a?(Prism::ClassNode) && scope.superclass
+    end
   end
 
   def superclass_range(class_node)
@@ -39,34 +43,4 @@ class Evilution::Mutator::Operator::SuperclassRemoval < Evilution::Mutator::Base
 
     [name_end, superclass_end - name_end]
   end
-
-  def find_enclosing_class(tree, target_line)
-    finder = ClassFinder.new(target_line)
-    finder.visit(tree)
-    finder.result
-  end
-
-  def find_first_method_line(class_node)
-    return nil unless class_node.body
-
-    class_node.body.body.each do |node|
-      return node.location.start_line if node.is_a?(Prism::DefNode)
-    end
-    nil
-  end
-
-  # Visitor to find the ClassNode enclosing a given line number.
-  class ClassFinder < Prism::Visitor
-    attr_reader :result
-
-    def initialize(target_line)
-      @target_line = target_line
-      @result = nil
-    end
-
-    def visit_class_node(node)
-      @result = node if @target_line.between?(node.location.start_line, node.location.end_line)
-      super
-    end
-  end
 end

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

@@ -1,10 +1,27 @@
 # frozen_string_literal: true
 
 require_relative "../operator"
+require_relative "../../ast/round_half_mode"
 
 class Evilution::Mutator::Operator::SymbolLiteral < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
+  def call(subject, filter: nil)
+    @round_half_modes = []
+    super
+  end
+
+  # The tie-breaking mode of `round` (`half: :even`) is left to
+  # RoundHalfModeSwap: a made-up symbol there only raises, and nil rounds
+  # like `:up`.
+  def visit_call_node(node)
+    mode = Evilution::AST::RoundHalfMode.of(node)
+    @round_half_modes << mode if mode
+    super
+  end
+
   def visit_symbol_node(node)
-    return super if label_form?(node)
+    return super if label_form?(node) || round_half_mode?(node)
 
     add_mutation(
       offset: node.location.start_offset,
@@ -23,10 +40,38 @@ class Evilution::Mutator::Operator::SymbolLiteral < Evilution::Mutator::Base
     super
   end
 
+  # An interpolated symbol (`:"visit_#{type}"`) as a whole. A label key
+  # (`"a#{x}": 1`) cannot be replaced by a value, and a word of `%I[]` has no
+  # quotes of its own: `nil` there would be the symbol `:nil`.
+  def visit_interpolated_symbol_node(node)
+    return super if node.opening_loc.nil? || label_form?(node)
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: ':""',
+      node: node
+    )
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "nil",
+      node: node
+    )
+
+    super
+  end
+
   private
 
+  def round_half_mode?(node)
+    @round_half_modes.any? { |mode| mode.equal?(node) }
+  end
+
+  # `a:` closes with `:`, a quoted label (`"a b":`) with `":`.
   def label_form?(node)
     closing = node.closing_loc
-    !closing.nil? && closing.slice == ":"
+    !closing.nil? && closing.slice.end_with?(":")
   end
 end

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

@@ -29,7 +29,7 @@ class Evilution::Mutator::Operator::ToIToInteger < Evilution::Mutator::Base
   end
 
   def rewrite(node)
-    arguments = node.arguments ? node.arguments.arguments : []
+    arguments = argument_nodes(node)
     return if arguments.length > 1 || arguments.any?(Prism::SplatNode)
 
     parts = [node.receiver, *arguments].map { |part| source_of(part) }

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a variable read with `nil`: a local, an instance, class or global
+# variable, or `self`.
+#
+# A survivor means the value read never reaches an assertion — the tests
+# would pass whatever the variable held. Where the read is passed as a
+# positional argument or interpolated into a string, the mutant is the one
+# argument_nil_substitution or string_interpolation already emits, and the
+# two are counted once.
+#
+# Positions where `nil` says nothing new are skipped:
+#
+# - the receiver of a call, which turns into `nil.name` — a NoMethodError
+#   any test that reaches it kills — and likewise the receiver of a write
+#   (`counter.total += 1`, `cache[key] ||= value`);
+# - a void statement (every statement of a body except the last), which
+#   statement_deletion deletes;
+# - the condition of an `if`, `unless`, `while` or `until`, where `nil` is
+#   the `false` conditional_negation already tries;
+# - the left operand of `&&` or `||`, where `nil && b` is the whole
+#   expression turned to nil and `nil || b` is `b` promoted;
+# - a block-pass argument, `&nil` being the call without its block;
+# - a double-splatted read, `**nil` raising before Ruby 3.4;
+# - the value a shorthand hash (`name:`) leaves unwritten.
+class Evilution::Mutator::Operator::VariableReadToNil < Evilution::Mutator::Base
+  include Evilution::Mutator::ReceiverPositions
+
+  def call(subject, **)
+    @skipped_nodes = Set.new
+    super
+  end
+
+  def visit_statements_node(node)
+    @skipped_nodes.merge(node.body[...-1])
+    super
+  end
+
+  def visit_if_node(node)
+    @skipped_nodes.add(node.predicate)
+    super
+  end
+
+  def visit_unless_node(node)
+    @skipped_nodes.add(node.predicate)
+    super
+  end
+
+  def visit_while_node(node)
+    @skipped_nodes.add(node.predicate)
+    super
+  end
+
+  def visit_until_node(node)
+    @skipped_nodes.add(node.predicate)
+    super
+  end
+
+  def visit_and_node(node)
+    @skipped_nodes.add(node.left)
+    super
+  end
+
+  def visit_or_node(node)
+    @skipped_nodes.add(node.left)
+    super
+  end
+
+  def visit_block_argument_node(node)
+    @skipped_nodes.add(node.expression)
+    super
+  end
+
+  def visit_assoc_splat_node(node)
+    @skipped_nodes.add(node.value)
+    super
+  end
+
+  # The read inside has no source of its own: it shares the key's.
+  def visit_implicit_node(_node); end
+
+  def visit_local_variable_read_node(node)
+    nilify(node)
+  end
+
+  def visit_instance_variable_read_node(node)
+    nilify(node)
+  end
+
+  def visit_class_variable_read_node(node)
+    nilify(node)
+  end
+
+  def visit_global_variable_read_node(node)
+    nilify(node)
+  end
+
+  def visit_self_node(node)
+    nilify(node)
+  end
+
+  private
+
+  def receiver_found(node)
+    @skipped_nodes.add(node)
+  end
+
+  def nilify(node)
+    mutate_to_nil(node) unless @skipped_nodes.include?(node)
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+require_relative "../../ast/class_body"
+
+# Drop a visibility declaration from a class or module body: `private`,
+# `protected` and `module_function`, bare or naming methods. A definition the
+# declaration wraps is kept: `private def a; end` becomes `def a; end`.
+#
+# A survivor means no example checks what the declaration decides: that a
+# private method cannot be called from outside, or that a module function
+# can.
+#
+# Declarations sit in the class body, outside every method, where no subject
+# reaches them. They are attributed to the method anchoring the enclosing
+# body (see Evilution::AST::ClassBody); a top-level declaration has no body
+# to be attributed to. A call inside a method, or one sent to another
+# receiver, is not a declaration.
+class Evilution::Mutator::Operator::VisibilityRemoval < Evilution::Mutator::Base
+  DECLARATIONS = %i[private protected module_function].freeze
+
+  # What a declaration can wrap and has to leave behind: a method definition,
+  # or a call (`private attr_reader :name`, `private helper_names`). The call
+  # runs with or without the declaration, so it stays.
+  WRAPPED = [Prism::DefNode, Prism::CallNode].freeze
+
+  def call(subject, filter: nil)
+    @subject = subject
+    @file_source = File.read(subject.file_path)
+    @mutations = []
+    @filter = filter
+
+    declarations_for(subject).each { |declaration| remove(declaration) }
+    @mutations
+  end
+
+  private
+
+  def remove(declaration)
+    replacement = replacement_for(argument_nodes(declaration))
+    return if replacement.nil?
+
+    add_mutation(
+      offset: declaration.location.start_offset,
+      length: declaration.location.length,
+      replacement: replacement,
+      node: declaration
+    )
+  end
+
+  # What is left of the declaration: nothing when it only names methods, the
+  # definition when it wraps one. A definition among several arguments
+  # (`private attr_reader(:a), :b`) cannot be left behind on its own, so that
+  # declaration is not mutated.
+  def replacement_for(arguments)
+    return "" if arguments.none? { |argument| WRAPPED.include?(argument.class) }
+
+    arguments.first.slice if arguments.one?
+  end
+
+  def declarations_for(subject)
+    tree = self.class.parsed_tree_for(subject.file_path, @file_source)
+
+    Evilution::AST::ClassBody.anchored_at(tree, subject.line_number).flat_map do |body|
+      body.declarations { |node| declaration?(node) }
+    end
+  end
+
+  def declaration?(node)
+    node.is_a?(Prism::CallNode) && node.receiver.nil? && DECLARATIONS.include?(node.name)
+  end
+end

data/lib/evilution/mutator/primitives.rb

@@ -3,8 +3,9 @@
 require_relative "../mutator"
 
 # Mutation shapes shared across the operator families: replacing an
-# expression with `nil`, and replacing an expression with the source of one
-# of its children. Both are built on Base#add_mutation, so the
+# expression with `nil`, replacing an expression with the source of one of
+# its children, and deleting one element of a list. All are built on
+# Base#add_mutation, so the
 # equivalent-mutant filter and the heredoc-span guards still apply.
 #
 # Unlike a bare add_mutation call, these skip rather than emit when the
@@ -30,6 +31,20 @@ module Evilution::Mutator::Primitives
     replace_span(node: node, target: target, replacement: source_of(child))
   end
 
+  # Delete the element at `index` from a list written in source order (the
+  # elements of an array or hash literal), attributing the mutation to the
+  # element. It goes with the separator after it; the last one goes with the
+  # separator before it, so a trailing comma stays where it was. The list
+  # must hold another element to take the separator from.
+  def delete_element(elements, index)
+    element = elements[index]
+    following = elements[index + 1]
+    offset = following ? element.location.start_offset : elements[index - 1].location.end_offset
+    stop = following ? following.location.start_offset : element.location.end_offset
+
+    add_mutation(offset:, length: stop - offset, replacement: "", node: element, skip_unparseable: true)
+  end
+
   def replace_span(node:, target:, replacement:)
     return nil if target.nil?
 
@@ -45,6 +60,13 @@ module Evilution::Mutator::Primitives
     )
   end
 
+  # The arguments of a call, `super`, `yield` or the like, in source order.
+  # Prism gives nil, not an empty list, where there are none; this gives the
+  # empty list, so a reader can count or iterate without asking first.
+  def argument_nodes(node)
+    node.arguments ? node.arguments.arguments : []
+  end
+
   def source_of(child)
     location = child.location
     byteslice_source(location.start_offset, location.length)