evilution 1.3.0 → 1.5.0

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+require_relative "../../ast/regexp_pattern"
+
+# Swap a regexp quantifier between "zero or more" and "one or more": `*`
+# becomes `+` and `+` becomes `*`, keeping a lazy (`*?`) or possessive (`*+`)
+# quantifier lazy or possessive.
+#
+# Only the empty case changes: `/\A\d*\z/` accepts "" and `/\A\d+\z/` does
+# not. A survivor means no example checks how the pattern treats an absent
+# repetition. RegexSimplification's quantifier removal changes the many case
+# too; this isolates the empty one.
+#
+# Making a recursive `\g<name>` call mandatory can make the pattern recurse
+# forever, so each mutant is compiled first and dropped if it does not.
+class Evilution::Mutator::Operator::RegexpQuantifierMinimumSwap < Evilution::Mutator::Base
+  SWAPS = {
+    zero_or_more: "+", zero_or_more_reluctant: "+?", zero_or_more_possessive: "++",
+    one_or_more: "*", one_or_more_reluctant: "*?", one_or_more_possessive: "*+"
+  }.freeze
+
+  def visit_regular_expression_node(node)
+    pattern = Evilution::AST::RegexpPattern.parse(node)
+    pattern.tokens.each { |token| swap(node, pattern, token) } if pattern
+    super
+  end
+
+  private
+
+  def swap(node, pattern, token)
+    return unless token.type == :quantifier
+
+    replacement = SWAPS[token.token]
+    return if replacement.nil?
+    return unless pattern.compiles?(token.start_offset, token.end_offset, replacement)
+
+    add_mutation(
+      offset: token.start_offset,
+      length: token.end_offset - token.start_offset,
+      replacement: replacement,
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Widen what a rescue clause catches: `rescue KeyError` becomes
+# `rescue StandardError` and `rescue Exception`.
+#
+# A survivor means no example raises a sibling error that has to get past
+# the handler, so nothing shows the clause needs to be as narrow as it is.
+#
+# A bare `rescue` is `rescue StandardError`, so the two are never offered as
+# mutants of each other; both go to `Exception` only. So does a clause naming
+# a core class outside `StandardError` (`Interrupt`, `LoadError`), which
+# `StandardError` would not widen but replace. A class of the program's own
+# is taken to be a `StandardError`. A clause that already names `Exception`
+# cannot be widened. A rescue modifier (`x rescue y`) takes no class and is
+# left alone.
+class Evilution::Mutator::Operator::RescueClassWidening < Evilution::Mutator::Base
+  WIDER = %w[StandardError Exception].freeze
+
+  # The core classes that descend from Exception but not from StandardError.
+  OUTSIDE_STANDARD_ERROR = %w[
+    NoMemoryError ScriptError LoadError NotImplementedError SyntaxError SecurityError SignalException Interrupt
+    SystemExit SystemStackError
+  ].freeze
+
+  def visit_rescue_node(node)
+    wider_than(node.exceptions).each { |name| widen(node, name) }
+    super
+  end
+
+  private
+
+  # The classes of WIDER above everything the clause lists.
+  def wider_than(exceptions)
+    listed = exceptions.map { |exception| exception.slice.delete_prefix("::") }
+    return [] if listed.include?(WIDER.last)
+    return [WIDER.last] if listed.empty? || listed.include?(WIDER.first) || listed.intersect?(OUTSIDE_STANDARD_ERROR)
+
+    WIDER
+  end
+
+  def widen(node, name)
+    exceptions = node.exceptions
+    return insert_after_keyword(node, name) if exceptions.empty?
+
+    offset = exceptions.first.location.start_offset
+    add_mutation(offset:, length: exceptions.last.location.end_offset - offset, replacement: name, node:)
+  end
+
+  def insert_after_keyword(node, name)
+    add_mutation(offset: node.keyword_loc.end_offset, length: 0, replacement: " #{name}", node:)
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+require_relative "../rescue_handlers"
+
+# Move the else clause of a rescue into the code it guards, keeping the rescue:
+#
+#   begin                    begin
+#     fetch(id)                fetch(id)
+#   rescue StandardError ->    notify
+#     default                rescue StandardError
+#   else                       default
+#     notify                 end
+#   end
+#
+# The else code still runs only when the body succeeded; the one thing that
+# changes is that an error it raises is now caught by the rescue, where an
+# else clause is not protected. A survivor means no test lets the else code
+# fail in a way the rescue would swallow.
+#
+# Only a rescue with at least one broad clause — a bare `rescue`, or one
+# naming StandardError or Exception — is mutated. Under a rescue for specific
+# classes the moved code changes behaviour only if it raises one of them,
+# which it rarely does, so those mutants would mostly survive without saying
+# anything. An empty else clause and a rescue around an empty body are
+# skipped; ensure clauses and every rescue clause stay as written.
+class Evilution::Mutator::Operator::RescueElseConcatenation < Evilution::Mutator::Base
+  BROAD_EXCEPTIONS = %w[StandardError ::StandardError Exception ::Exception].freeze
+
+  def visit_begin_node(node)
+    else_clause = node.else_clause
+    move_else(node, else_clause) if node.statements && else_clause && else_clause.statements && broad_rescue?(node)
+    super
+  end
+
+  private
+
+  def broad_rescue?(node)
+    Evilution::Mutator::RescueHandlers.new(node).clauses.any? do |clause|
+      clause.exceptions.empty? || clause.exceptions.any? { |exception| BROAD_EXCEPTIONS.include?(exception.slice) }
+    end
+  end
+
+  # One edit from the end of the body to the end of the else body: the else
+  # statements go first, then the rescue clauses as they were, with the
+  # whitespace (and a one-line `;`) that led into `else` trimmed off.
+  def move_else(node, else_clause)
+    body_end = node.statements.location.end_offset
+    continuation = Evilution::Mutator::RescueHandlers.continuation(@file_source, node.statements)
+
+    add_mutation(
+      offset: body_end,
+      length: else_clause.statements.location.end_offset - body_end,
+      replacement: "#{continuation}#{else_clause.statements.slice}#{rescue_clauses_text(body_end, else_clause)}",
+      node: else_clause
+    )
+  end
+
+  def rescue_clauses_text(body_end, else_clause)
+    byteslice_source(body_end, else_clause.else_keyword_loc.start_offset - body_end).rstrip.delete_suffix(";")
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+require_relative "../rescue_handlers"
+
+# Run a rescue handler after the code it protects as well, keeping the rescue:
+#
+#   begin                  begin
+#     fetch(id)              fetch(id)
+#   rescue NotFound    ->    rollback
+#     rollback             rescue NotFound
+#   end                      rollback
+#                          end
+#
+# The failure path is untouched; only a successful run changes, now also
+# doing what the handler does. A survivor means the handler is harmless when
+# nothing failed — the tests never show it is meant for the failure only.
+# Dropping the rescue as well would repeat RescueRemoval and hide this signal
+# behind any test of the failure path.
+#
+# With several rescue clauses each handler is used in its own mutant. An empty
+# handler adds nothing and is skipped, as is one that only produces a value
+# (`nil`, a literal, a variable, a bare `next`): run after the body it changes
+# nothing but the return value, which RescueHandlerPromotion already probes.
+# Handlers that only work inside the rescue are skipped too (see
+# Mutator::RescueHandlers). A rescue modifier sits in value position, where a
+# statement sequence does not fit, and is left alone.
+class Evilution::Mutator::Operator::RescueHandlerConcatenation < Evilution::Mutator::Base
+  VALUE_TYPES = [
+    Prism::NilNode, Prism::TrueNode, Prism::FalseNode, Prism::IntegerNode, Prism::FloatNode,
+    Prism::StringNode, Prism::SymbolNode, Prism::SelfNode, Prism::ConstantReadNode,
+    Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode
+  ].freeze
+
+  def visit_begin_node(node)
+    append_handlers(node) if node.rescue_clause && node.statements
+    super
+  end
+
+  private
+
+  def append_handlers(node)
+    body_end = node.statements.location.end_offset
+    separator = Evilution::Mutator::RescueHandlers.continuation(@file_source, node.statements)
+
+    Evilution::Mutator::RescueHandlers.new(node).clauses.each do |clause|
+      handler = clause.statements
+      next if handler.nil? || value_only?(handler)
+      next unless Evilution::Mutator::RescueHandlers.movable?(handler, clause.reference)
+
+      add_mutation(offset: body_end, length: 0, replacement: "#{separator}#{handler.slice}", node: clause)
+    end
+  end
+
+  def value_only?(handler)
+    handler.body.all? { |statement| value?(statement) }
+  end
+
+  # A method call may act, so only literals, plain reads and a bare `next` /
+  # `return` count.
+  def value?(statement)
+    case statement
+    when *VALUE_TYPES then true
+    when Prism::ArrayNode, Prism::HashNode then statement.elements.empty?
+    when Prism::NextNode, Prism::ReturnNode then statement.arguments.nil?
+    else false
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+require_relative "../rescue_handlers"
+
+# Run a rescue handler instead of the code it protects:
+# `begin; fetch(id); rescue NotFound; default; end` becomes
+# `begin; default; end`, a method-level rescue does the same to the method
+# body, and `fetch(id) rescue default` becomes `default`.
+#
+# The happy path never runs, so a survivor means the tests accept the
+# fallback value where the real result was expected — they never check what
+# the protected code returns.
+#
+# With several rescue clauses each handler is promoted in its own mutant. An
+# else clause goes with the body, since it only runs when nothing is rescued;
+# an ensure clause stays. An empty handler becomes `nil`, what a swallowed
+# error returns.
+#
+# Handlers that only make sense inside the rescue are skipped, since promoted
+# they fail for that reason alone; Mutator::RescueHandlers holds the rule.
+class Evilution::Mutator::Operator::RescueHandlerPromotion < Evilution::Mutator::Base
+  def visit_begin_node(node)
+    promote_handlers(node) if node.rescue_clause && node.statements
+    super
+  end
+
+  def visit_rescue_modifier_node(node)
+    fallback = node.rescue_expression
+    replace(node, fallback.slice, node) if Evilution::Mutator::RescueHandlers.movable?(fallback, nil)
+    super
+  end
+
+  private
+
+  def promote_handlers(node)
+    start_offset = node.statements.location.start_offset
+    end_offset = protected_end(node)
+
+    Evilution::Mutator::RescueHandlers.new(node).clauses.each do |clause|
+      next unless Evilution::Mutator::RescueHandlers.movable?(clause.statements, clause.reference)
+
+      handler = clause.statements ? clause.statements.slice : "nil"
+      add_mutation(offset: start_offset, length: end_offset - start_offset, replacement: handler, node: clause)
+    end
+  end
+
+  # The body, every rescue clause and an else clause are replaced; an ensure
+  # clause and the closing `end` stay. A rescue clause's location runs on
+  # through the clauses after it, and an else clause's up to the keyword that
+  # follows it, so the span ends at the last clause's own content.
+  def protected_end(node)
+    else_clause = node.else_clause
+    return Evilution::Mutator::RescueHandlers.new(node).clauses.last.location.end_offset if else_clause.nil?
+
+    return else_clause.statements.location.end_offset if else_clause.statements
+
+    else_clause.else_keyword_loc.end_offset
+  end
+
+  def replace(target, replacement, node)
+    location = target.location
+    add_mutation(offset: location.start_offset, length: location.length, replacement: replacement, node: node)
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+require_relative "../rescue_handlers"
+
+# Drop the `return` keyword and keep its value: `return :neg if x.negative?`
+# becomes `:neg if x.negative?`.
+#
+# Control flow continues past the point where the method used to leave, so a
+# survivor means no test notices the code after a guard clause or an early
+# return running anyway. ReturnValueRemoval keeps the early exit and drops the
+# value; this keeps the value and drops the exit. Several values become an
+# array, as `return` would make them: `return a, b` becomes `[a, b]`.
+#
+# A return in tail position — the method's last statement, the last statement
+# of a branch that is itself in tail position, or the tail of a lambda — is
+# skipped: its value is the result either way. A return inside a block always
+# leaves the method, so it is never tail position. A bare `return` has no
+# value to keep.
+class Evilution::Mutator::Operator::ReturnKeywordRemoval < Evilution::Mutator::Base
+  # For each node that passes a value on, the parts whose value becomes its
+  # own. With an else clause a begin body's value is not the result, the
+  # else's is; each rescue handler's value can be the result too.
+  TAIL_PARTS = {
+    Prism::StatementsNode => ->(node) { [node.body.last] },
+    Prism::ParenthesesNode => ->(node) { [node.body] },
+    Prism::ElseNode => ->(node) { [node.statements] },
+    Prism::IfNode => ->(node) { [node.statements, node.subsequent] },
+    Prism::UnlessNode => ->(node) { [node.statements, node.else_clause] },
+    Prism::CaseNode => ->(node) { [*node.conditions.map(&:statements), node.else_clause] },
+    Prism::CaseMatchNode => ->(node) { [*node.conditions.map(&:statements), node.else_clause] },
+    Prism::BeginNode => lambda { |node|
+      [node.else_clause || node.statements, *Evilution::Mutator::RescueHandlers.new(node).clauses.map(&:statements)]
+    }
+  }.freeze
+
+  def initialize(**options)
+    super
+    @tail_returns = Set.new.compare_by_identity
+  end
+
+  def visit_def_node(node)
+    @tail_returns.merge(tail_returns(node.body))
+    super
+  end
+
+  def visit_lambda_node(node)
+    @tail_returns.merge(tail_returns(node.body))
+    super
+  end
+
+  def visit_return_node(node)
+    drop_keyword(node) if node.arguments && !@tail_returns.include?(node)
+    super
+  end
+
+  private
+
+  def drop_keyword(node)
+    arguments = node.arguments.arguments
+    value = if arguments.length == 1 && !arguments.first.is_a?(Prism::SplatNode)
+              arguments.first.slice
+            else
+              "[#{arguments.map(&:slice).join(", ")}]"
+            end
+
+    add_mutation(offset: node.location.start_offset, length: node.location.length, replacement: value, node: node)
+  end
+
+  # The returns whose value is the value of `node` itself.
+  def tail_returns(node)
+    return [node] if node.is_a?(Prism::ReturnNode)
+
+    parts = TAIL_PARTS[node.class]
+    return [] if parts.nil?
+
+    parts.call(node).compact.flat_map { |part| tail_returns(part) }
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Turn a rightward pattern match into a pattern predicate: `value => [a, b]`
+# becomes `value in [a, b]`.
+#
+# On a mismatch the original raises NoMatchingPatternError, while the predicate
+# returns false and leaves the pattern's variables nil. A survivor means no
+# example feeds the match a value it rejects, so the failure mode is untested.
+class Evilution::Mutator::Operator::RightwardAssignment < Evilution::Mutator::Base
+  def visit_match_required_node(node)
+    replace_operator(node) unless irrefutable?(node.pattern)
+    super
+  end
+
+  private
+
+  def replace_operator(node)
+    location = node.operator_loc
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: keyword_for(node),
+      node: node
+    )
+  end
+
+  # `=>` is punctuation and may touch its neighbours (`value=>Integer`), but
+  # `in` is a word: written flush against them it would merge into a single
+  # name. A space is added on each side that has none.
+  def keyword_for(node)
+    location = node.operator_loc
+    before = node.value.location.end_offset == location.start_offset ? " " : ""
+    after = node.pattern.location.start_offset == location.end_offset ? " " : ""
+
+    "#{before}in#{after}"
+  end
+
+  # A bare name (`value => captured`, `value => _`) captures any value, so the
+  # match can never raise and the predicate form would behave the same.
+  def irrefutable?(pattern)
+    pattern.is_a?(Prism::LocalVariableTargetNode)
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+require_relative "../../ast/round_half_mode"
+
+# Swap the tie-breaking mode of `round`: `amount.round(2, half: :even)`
+# becomes `half: :up` and `half: :down`.
+#
+# The modes differ only for a value sitting exactly on a tie (`2.5`), so a
+# survivor means no example rounds one — the case banker's rounding in money
+# code exists for.
+#
+# Only a literal mode is swapped; one held in a variable is left alone.
+# Integer, Float, Rational and BigDecimal all read `half:` the same way.
+class Evilution::Mutator::Operator::RoundHalfModeSwap < Evilution::Mutator::Base
+  def visit_call_node(node)
+    mode = Evilution::AST::RoundHalfMode.of(node)
+    swap(node, mode) if mode
+    super
+  end
+
+  private
+
+  def swap(node, mode)
+    others = Evilution::AST::RoundHalfMode::MODES - [mode.unescaped.to_sym]
+
+    others.each do |other|
+      add_mutation(
+        offset: mode.location.start_offset,
+        length: mode.location.length,
+        replacement: other.inspect,
+        node: node
+      )
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+require_relative "../../ast/never_nil"
+
+# Replace a plain call with safe navigation: `user.name` becomes
+# `user&.name`, and the same for the `||=`, `&&=` and operator-write forms.
+#
+# The mutant only differs when the receiver is nil: the call is then skipped
+# and the expression is nil, where the plain call raises NoMethodError or
+# runs a method nil has (`nil.to_a` is `[]`). A survivor means no test
+# reaches the call with a nil receiver and checks what comes of it.
+#
+# It touches nearly every call and survives wherever the receiver is never
+# nil, so it is registered for the strict profile only. Receivers that can
+# never be nil (`self`, literals other than `nil`, constants) are skipped,
+# since the mutant is equivalent there.
+class Evilution::Mutator::Operator::SafeNavigationInsertion < Evilution::Mutator::Base
+  # A constant could hold nil, but one that receives a call does not in
+  # practice.
+  CONSTANTS = [Prism::ConstantReadNode, Prism::ConstantPathNode].freeze
+  private_constant :CONSTANTS
+
+  def visit_call_node(node)
+    mutate_plain_call(node)
+    super
+  end
+
+  def visit_call_or_write_node(node)
+    mutate_plain_call(node)
+    super
+  end
+
+  def visit_call_and_write_node(node)
+    mutate_plain_call(node)
+    super
+  end
+
+  def visit_call_operator_write_node(node)
+    mutate_plain_call(node)
+    super
+  end
+
+  private
+
+  def mutate_plain_call(node)
+    operator = node.call_operator_loc
+    return unless operator && operator.slice == "."
+    return if never_nil?(node.receiver)
+
+    add_mutation(offset: operator.start_offset, length: operator.length, replacement: "&.", node: node)
+  end
+
+  def never_nil?(receiver)
+    Evilution::AST::NeverNil.node?(receiver) || CONSTANTS.include?(receiver.class)
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../operator"
+require_relative "../../ast/never_nil"
 
 # Replace safe navigation with a plain call: `user&.name` becomes
 # `user.name`, and the same for the `||=`, `&&=` and operator-write forms.
@@ -12,29 +13,6 @@ require_relative "../operator"
 # Receivers that can never be nil — `self` and literals — are skipped, since
 # the mutant is equivalent there.
 class Evilution::Mutator::Operator::SafeNavigationRemoval < Evilution::Mutator::Base
-  NEVER_NIL_RECEIVERS = [
-    Prism::SelfNode,
-    Prism::StringNode,
-    Prism::InterpolatedStringNode,
-    Prism::XStringNode,
-    Prism::InterpolatedXStringNode,
-    Prism::SymbolNode,
-    Prism::InterpolatedSymbolNode,
-    Prism::IntegerNode,
-    Prism::FloatNode,
-    Prism::RationalNode,
-    Prism::ImaginaryNode,
-    Prism::ArrayNode,
-    Prism::HashNode,
-    Prism::RangeNode,
-    Prism::RegularExpressionNode,
-    Prism::InterpolatedRegularExpressionNode,
-    Prism::TrueNode,
-    Prism::FalseNode,
-    Prism::LambdaNode
-  ].freeze
-  private_constant :NEVER_NIL_RECEIVERS
-
   def visit_call_node(node)
     mutate_safe_navigation(node)
     super
@@ -59,7 +37,7 @@ class Evilution::Mutator::Operator::SafeNavigationRemoval < Evilution::Mutator::
 
   def mutate_safe_navigation(node)
     return unless node.safe_navigation?
-    return if NEVER_NIL_RECEIVERS.any? { |type| node.receiver.is_a?(type) }
+    return if Evilution::AST::NeverNil.node?(node.receiver)
 
     operator = node.call_operator_loc
     add_mutation(offset: operator.start_offset, length: operator.length, replacement: ".", node: node)

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

@@ -43,6 +43,8 @@ class Evilution::Mutator::Operator::SendMutation < Evilution::Mutator::Base
     end_with?: [:start_with?],
     ceil: [:floor],
     floor: [:ceil],
+    round: %i[floor ceil],
+    truncate: [:floor],
     transform_keys: [:transform_values],
     transform_values: [:transform_keys],
     append: [:prepend],

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Make a short-circuit operator evaluate both sides: `a && b` becomes
+# `a & b`, `a || b` becomes `a | b`.
+#
+# A survivor means no example depends on the right side being skipped: it
+# guards nothing (a nil receiver, a side effect), and both sides are plain
+# booleans, since `&` and `|` give another value for anything else.
+#
+# `&` and `|` bind tighter than `&&` and `||`, so an operand that would
+# regroup (`a == 1 && b` is not `a == 1 & b`) is parenthesized.
+class Evilution::Mutator::Operator::ShortCircuitToEager < Evilution::Mutator::Base
+  def visit_and_node(node)
+    mutate_to_eager(node, "&")
+    super
+  end
+
+  def visit_or_node(node)
+    mutate_to_eager(node, "|")
+    super
+  end
+
+  private
+
+  # An operand that only jumps (`a || return`) has no value to pass on; the
+  # result does not parse and is dropped.
+  def mutate_to_eager(node, operator)
+    replacement = "#{receiver_source(node.left)} #{operator} #{receiver_source(node.right)}"
+
+    replace_span(node:, target: node, replacement:)
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Take the wait out of a sleep whose duration is not a literal:
+# `sleep delay` becomes `sleep 0`.
+#
+# A survivor means the pause decides nothing an example observes. A killed
+# mutant means the suite depends on wall-clock time, which is worth knowing
+# too.
+#
+# A literal duration (`sleep 5`, `sleep 0.5`) is left to the literal
+# operators, which already take it to zero. Only `Kernel#sleep` is touched: a
+# `sleep` sent to another receiver may be something else.
+class Evilution::Mutator::Operator::SleepToZero < Evilution::Mutator::Base
+  LITERAL_DURATIONS = [Prism::IntegerNode, Prism::FloatNode, Prism::RationalNode].freeze
+  KERNEL = %w[Kernel ::Kernel].freeze
+
+  def visit_call_node(node)
+    duration = duration_of(node)
+    add_mutation(offset: duration.location.start_offset, length: duration.location.length, replacement: "0", node:) if duration
+
+    super
+  end
+
+  private
+
+  # The single argument of a `sleep` call, when it is one this operator
+  # replaces.
+  def duration_of(node)
+    return unless node.name == :sleep && kernel_call?(node) && node.arguments
+
+    arguments = node.arguments.arguments
+    return unless arguments.one?
+
+    duration = arguments.first
+    duration unless duration.is_a?(Prism::SplatNode) || LITERAL_DURATIONS.include?(duration.class)
+  end
+
+  def kernel_call?(node)
+    node.receiver.nil? || KERNEL.include?(node.receiver.slice)
+  end
+end