evilution 1.4.0 → 1.5.0

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+require_relative "../../ast/class_body"
+
+# Drop the `freeze` of a constant defined in a class or module body:
+# `LIST = %w[a b].freeze` becomes `LIST = %w[a b]`.
+#
+# A survivor means no example tries to change the shared value, so nothing
+# shows that it has to stay as it is.
+#
+# A constant is defined in the class body, outside every method, where no
+# subject reaches it. The mutation is attributed to the method anchoring the
+# enclosing body (see Evilution::AST::ClassBody); a top-level constant has no
+# body to be attributed to. A `freeze` inside a method is left to the generic
+# call operators, which already drop it.
+class Evilution::Mutator::Operator::FreezeRemoval < Evilution::Mutator::Base
+  CONSTANT_WRITES = [Prism::ConstantWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantOrWriteNode].freeze
+
+  # Values that are frozen whether or not `freeze` is called.
+  ALWAYS_FROZEN = [
+    Prism::SymbolNode, Prism::IntegerNode, Prism::FloatNode, Prism::RationalNode, Prism::ImaginaryNode,
+    Prism::NilNode, Prism::TrueNode, Prism::FalseNode, Prism::RangeNode, Prism::RegularExpressionNode
+  ].freeze
+
+  # The comments a file opens with, where the magic comment has to be.
+  LEADING_COMMENTS = /\A(?:[ \t]*(?:#.*)?\n)*/
+  FROZEN_STRING_LITERALS = /^[ \t]*#.*frozen[_-]string[_-]literal:[ \t]*true/i
+  private_constant :CONSTANT_WRITES, :ALWAYS_FROZEN, :LEADING_COMMENTS, :FROZEN_STRING_LITERALS
+
+  def call(subject, filter: nil)
+    @subject = subject
+    @file_source = File.read(subject.file_path)
+    @mutations = []
+    @filter = filter
+
+    constant_writes_for(subject).each { |write| freezes_in(write).each { |freeze_call| remove(freeze_call) } }
+    @mutations
+  end
+
+  private
+
+  def remove(freeze_call)
+    add_mutation(
+      offset: freeze_call.location.start_offset,
+      length: freeze_call.location.length,
+      replacement: freeze_call.receiver.slice,
+      node: freeze_call
+    )
+  end
+
+  def constant_writes_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| CONSTANT_WRITES.include?(node.class) }
+    end
+  end
+
+  # Every `freeze` call under the node, outermost first.
+  def freezes_in(node)
+    nested = node.compact_child_nodes.flat_map { |child| freezes_in(child) }
+    removable_freeze?(node) ? [node, *nested] : nested
+  end
+
+  def removable_freeze?(node)
+    return false unless node.is_a?(Prism::CallNode) && node.name == :freeze
+    return false if node.receiver.nil? || node.arguments
+
+    !frozen_anyway?(node.receiver)
+  end
+
+  # A group has the value of its last expression: `(1..2)`.
+  def frozen_anyway?(receiver)
+    receiver = receiver.body.body.last while receiver.is_a?(Prism::ParenthesesNode) && receiver.body
+    return true if ALWAYS_FROZEN.include?(receiver.class)
+
+    receiver.is_a?(Prism::StringNode) && frozen_string_literals?
+  end
+
+  def frozen_string_literals?
+    @file_source[LEADING_COMMENTS].match?(FROZEN_STRING_LITERALS)
+  end
+end

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

@@ -3,6 +3,10 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::HashLiteral < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
+  RENAMED_KEY = "__evilution_mutated__"
+
   def visit_hash_node(node)
     if node.elements.any?
       add_mutation(
@@ -18,8 +22,55 @@ class Evilution::Mutator::Operator::HashLiteral < Evilution::Mutator::Base
         replacement: "nil",
         node: node
       )
+
+      mutate_delete_pairs(node.elements)
+      mutate_rename_keys(node.elements)
     end
 
     super
   end
+
+  private
+
+  # Delete each key/value pair in turn: a survivor means no example checks
+  # that key. A single element is left to the `{}` replacement. A `**splat`
+  # is not a pair and stays. So does a pair holding a heredoc: its body sits
+  # after the closing brace, so one cut cannot take both, and the cut that
+  # does not parse is dropped.
+  def mutate_delete_pairs(elements)
+    return if elements.one?
+
+    elements.each_with_index do |element, index|
+      delete_element(elements, index) if element.is_a?(Prism::AssocNode)
+    end
+  end
+
+  # Rename each label key in turn (`a: 1`, `"a b": 1`): a survivor means no
+  # example reads the value by that name. A key written with a rocket
+  # (`:a => 1`, `"a" => 1`) is a literal of its own, and SymbolLiteral and
+  # StringLiteral already replace it.
+  def mutate_rename_keys(elements)
+    elements.each do |element|
+      rename_key(element) if element.is_a?(Prism::AssocNode) && label?(element.key)
+    end
+  end
+
+  def label?(key)
+    key.is_a?(Prism::SymbolNode) && !key.closing.nil? && key.closing.end_with?(":")
+  end
+
+  # A shorthand pair (`{ x: }`) reads its value from the key, so the value is
+  # written out to stay what it was.
+  def rename_key(pair)
+    key = pair.key
+    replacement = "#{RENAMED_KEY}:"
+    replacement += " #{key.unescaped}" if pair.value.is_a?(Prism::ImplicitNode)
+
+    add_mutation(
+      offset: key.location.start_offset,
+      length: key.location.length,
+      replacement: replacement,
+      node: key
+    )
+  end
 end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Take the tail of a list with `drop` instead of a range index:
+# `list[n..-1]` and the endless `list[n..]` / `list[n...]` become
+# `list.drop(n)`.
+#
+# The two differ only past the end: a start beyond the last element gives
+# `nil` from the index and an empty array from `drop`. A survivor means no
+# test reaches that boundary.
+#
+# A literal start of zero is skipped, never being out of range, and so is a
+# negative literal, which `drop` rejects with ArgumentError. A range that
+# stops short of the last element (`n...-1`, `n..-2`) is no tail at all. A
+# read in void statement position is left to statement_deletion, and index
+# writes are another method altogether.
+#
+# The receiver's type is unknown here: on a String the mutant raises
+# NoMethodError, which any test reaching the line kills.
+class Evilution::Mutator::Operator::IndexRangeToDrop < Evilution::Mutator::Base
+  LAST_INDEX = -1
+  private_constant :LAST_INDEX
+
+  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)
+    start = tail_start(node)
+    replace_span(node: node, target: node, replacement: drop_call(node, start)) if start
+    super
+  end
+
+  private
+
+  # Where the tail begins, when `node` reads from there to the last element.
+  # A beginless range has no start to hand to `drop`, and answers nil too.
+  def tail_start(node)
+    return unless node.name == :[] && !@void_statements.include?(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [Prism::RangeNode => range]]
+
+    range.left if to_the_end?(range) && droppable_start?(range.left)
+  end
+
+  def to_the_end?(range)
+    stop = range.right
+    return true if stop.nil?
+
+    !range.exclude_end? && stop.is_a?(Prism::IntegerNode) && stop.value == LAST_INDEX
+  end
+
+  def droppable_start?(start)
+    !start.is_a?(Prism::IntegerNode) || start.value.positive?
+  end
+
+  def drop_call(node, start)
+    operator = node.safe_navigation? ? "&." : "."
+    "#{source_of(node.receiver)}#{operator}drop(#{source_of(start)})"
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Send an index read to `self` instead of its receiver: `hash[key]` becomes
+# `self[key]`, arguments untouched.
+#
+# The survivor it targets lives in a class that defines its own `#[]` — a
+# collection or a wrapper that also holds the thing it indexes — where the
+# tests never tell the two lookups apart. Anywhere else the mutant raises
+# NoMethodError, which any test reaching the line kills.
+#
+# Index writes are left alone: `a[b] = c` is a different method, and the
+# operator-write forms (`a[b] ||= c`) are not calls at all.
+class Evilution::Mutator::Operator::IndexReceiverToSelf < Evilution::Mutator::Base
+  def visit_call_node(node)
+    replace_span(node: node, target: node.receiver, replacement: "self") if node.name == :[]
+    super
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Ask whether the key is there instead of reading it: `config[:size]`
+# becomes `config.key?(:size)`.
+#
+# The value turns into a boolean. A survivor means the tests only notice
+# that something came back — a condition taken, a truthy result — and never
+# what the lookup returned.
+#
+# Only a read with one plain argument qualifies, `key?` taking exactly one.
+# An integer or range index is skipped: it points at an Array or a String,
+# which has no `key?`, so the mutant would only raise NoMethodError. A read
+# in void statement position is left to statement_deletion, its value being
+# discarded either way. Index writes are another method altogether.
+class Evilution::Mutator::Operator::IndexToKeyPredicate < Evilution::Mutator::Base
+  # Argument shapes `key?` cannot take as its one key.
+  NON_KEY_ARGUMENTS = [
+    Prism::SplatNode,
+    Prism::KeywordHashNode,
+    Prism::BlockArgumentNode,
+    Prism::ForwardingArgumentsNode,
+    Prism::IntegerNode,
+    Prism::RangeNode
+  ].freeze
+  private_constant :NON_KEY_ARGUMENTS
+
+  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)
+    key = key_argument(node)
+    replace_span(node: node, target: node, replacement: key_predicate(node, key)) if key
+    super
+  end
+
+  private
+
+  def key_argument(node)
+    return unless node.name == :[] && !@void_statements.include?(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [argument]]
+
+    argument unless NON_KEY_ARGUMENTS.any? { |type| argument.is_a?(type) }
+  end
+
+  def key_predicate(node, key)
+    operator = node.safe_navigation? ? "&." : "."
+    "#{source_of(node.receiver)}#{operator}key?(#{source_of(key)})"
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace an index write with the value it assigns: `cache[key] = value`
+# becomes `value`.
+#
+# An index write evaluates to the assigned value, so the mutant returns just
+# what the original did — only the store is gone. A survivor means the tests
+# check what was computed and never that it was kept. That is what sets it
+# apart from deleting the statement or turning it into `nil`, both of which
+# also change the result.
+#
+# The result is kept for the assignment syntax only. The method-call
+# spelling is mutated as well, but there it may change: `cache.[]=(key,
+# value)` returns whatever `[]=` returns, and `cache&.[]=(key, value)` is
+# `nil`, with `value` never evaluated, when the receiver is `nil`.
+#
+# A write in void statement position is skipped: with its value discarded,
+# the mutant is statement_deletion's. Operator writes (`a[b] ||= c`) and
+# index targets of a multiple assignment are not calls and are left alone.
+class Evilution::Mutator::Operator::IndexWriteToValue < Evilution::Mutator::Base
+  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)
+    promote_child(node, argument_nodes(node).last) if node.name == :[]= && !@void_statements.include?(node)
+    super
+  end
+end

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

@@ -3,23 +3,53 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::IntegerLiteral < Evilution::Mutator::Base
-  def visit_integer_node(node)
-    if node.value.zero?
-      add_mutation_with_replacement(node, "1")
-    elsif node.value == 1
-      add_mutation_with_replacement(node, "0")
-    else
-      add_mutation_with_replacement(node, "0")
-      add_mutation_with_replacement(node, (node.value + 1).to_s)
-    end
+  extend Evilution::Mutator::ConstantValueSubjects
+
+  # One value past each integer width, keyed by the boundary it crosses:
+  # int8, uint8, int16, uint16, int32, uint32, int64. A literal is replaced
+  # with the sentinel of the first boundary above its magnitude, so a
+  # survivor means nothing checks that the value still fits its width. The
+  # sentinels are safe primes: arithmetic, masking or shifting does not land
+  # on one by coincidence.
+  WIDTH_SENTINELS = {
+    2**7 => 167,
+    2**8 => 467,
+    2**15 => 55_487,
+    2**16 => 108_503,
+    2**31 => 2_667_278_543,
+    2**32 => 7_980_081_959,
+    2**63 => 15_508_464_536_481_899_903
+  }.freeze
 
+  def visit_integer_node(node)
+    replacements_for(node.value).each { |value| add_mutation_with_replacement(node, value.to_s) }
     add_mutation_with_replacement(node, "nil")
 
     super
   end
 
+  # A complex literal (`5i`) is replaced as a whole by ComplexLiteral. Its
+  # numeric part is not a literal of its own: `nili` is not a value.
+  def visit_imaginary_node(_node); end
+
   private
 
+  def replacements_for(value)
+    [*neighbours_of(value), width_sentinel_for(value)].compact
+  end
+
+  def neighbours_of(value)
+    return [1, -1] if value.zero?
+    return [0] if value == 1
+
+    [0, value + 1, value - 1].uniq
+  end
+
+  def width_sentinel_for(value)
+    _boundary, sentinel = WIDTH_SENTINELS.find { |boundary, _| boundary > value.abs }
+    sentinel
+  end
+
   def add_mutation_with_replacement(node, replacement)
     add_mutation(offset: node.location.start_offset, length: node.location.length, replacement:, node:)
   end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Turn a memoizing assignment into a plain one: `@x ||= expr` becomes
+# `@x = expr`, so the value is computed again on every call.
+#
+# A survivor means no example tells one computation from several: nothing
+# counts the calls behind the value, and nothing depends on getting the same
+# object back.
+class Evilution::Mutator::Operator::MemoizationBreak < Evilution::Mutator::Base
+  def visit_instance_variable_or_write_node(node)
+    operator = node.operator_loc
+    add_mutation(offset: operator.start_offset, length: operator.length, replacement: "=", node: node)
+
+    super
+  end
+end

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

@@ -3,7 +3,15 @@
 require "prism"
 
 require_relative "../operator"
-
+require_relative "../../ast/class_body"
+
+# Drop a mixin from a class or module body: `include`, `extend` and `prepend`
+# calls are removed.
+#
+# The calls 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 mixin call inside a method is left
+# to the generic call operators.
 class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
   MIXIN_METHODS = %i[include extend prepend].freeze
 
@@ -13,22 +21,22 @@ class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
     @mutations = []
     @filter = filter
 
-    enclosing = find_target_scope(subject)
-    return @mutations unless enclosing
-
-    find_mixin_calls(enclosing).each { |call_node| emit_mixin_removal(call_node) }
+    mixin_calls_for(subject).each { |call_node| emit_mixin_removal(call_node) }
     @mutations
   end
 
   private
 
-  def find_target_scope(subject)
+  def mixin_calls_for(subject)
     tree = self.class.parsed_tree_for(subject.file_path, @file_source)
-    enclosing = find_enclosing_scope(tree, subject.line_number)
-    return nil unless enclosing
-    return nil unless find_first_method_line(enclosing) == subject.line_number
 
-    enclosing
+    Evilution::AST::ClassBody.anchored_at(tree, subject.line_number).flat_map do |body|
+      body.declarations { |node| mixin_call?(node) }
+    end
+  end
+
+  def mixin_call?(node)
+    node.is_a?(Prism::CallNode) && MIXIN_METHODS.include?(node.name) && node.receiver.nil?
   end
 
   def emit_mixin_removal(call_node)
@@ -39,49 +47,4 @@ class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
       node: call_node
     )
   end
-
-  def find_enclosing_scope(tree, target_line)
-    finder = ScopeFinder.new(target_line)
-    finder.visit(tree)
-    finder.result
-  end
-
-  def find_first_method_line(scope_node)
-    return nil unless scope_node.body
-
-    scope_node.body.body.each do |node|
-      return node.location.start_line if node.is_a?(Prism::DefNode)
-    end
-    nil
-  end
-
-  def find_mixin_calls(scope_node)
-    return [] unless scope_node.body
-
-    scope_node.body.body.select do |node|
-      node.is_a?(Prism::CallNode) &&
-        MIXIN_METHODS.include?(node.name) &&
-        node.receiver.nil?
-    end
-  end
-
-  # Visitor to find the ClassNode or ModuleNode enclosing a given line number.
-  class ScopeFinder < 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
-
-    def visit_module_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/nil_replacement.rb

@@ -3,6 +3,8 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::NilReplacement < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
   REPLACEMENTS = %w[true false 0 ""].freeze
 
   def visit_nil_node(node)

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Retarget an operator write on an attribute at the instance variable it
+# goes through: `@account.balance += amount` becomes `@account += amount`.
+#
+# The value is still computed and still assigned, only to the wrong place:
+# the object's attribute is left as it was and the variable is replaced. A
+# survivor means the tests exercise the line without ever looking at what it
+# was meant to change. Where the object does not answer the operator the
+# mutant raises NoMethodError, which any test reaching the line kills.
+#
+# Only a receiver that is an instance variable qualifies. `self` cannot be
+# assigned to, and behind a longer receiver (`@user.account.balance += x`)
+# sits another attribute, not a variable.
+class Evilution::Mutator::Operator::OperatorWriteReceiverPromotion < Evilution::Mutator::Base
+  def visit_call_operator_write_node(node)
+    promote_receiver(node) if node.receiver.is_a?(Prism::InstanceVariableReadNode)
+    super
+  end
+
+  private
+
+  # Replaces `@account.balance`, up to the end of the attribute's name, with
+  # `@account`. What is left is an operator write on a variable, which always
+  # parses.
+  def promote_receiver(node)
+    offset = node.start_offset
+
+    add_mutation(
+      offset: offset,
+      length: node.message_loc.end_offset - offset,
+      replacement: source_of(node.receiver),
+      node: node
+    )
+  end
+end

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

@@ -3,6 +3,8 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::RangeReplacement < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
   def visit_range_node(node)
     replacement = node.operator == ".." ? "..." : ".."
 

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a rational literal (`5r`, `1.5r`) with `0r`, `1r`, its two
+# neighbours (`value + 1r`, `value - 1r`) and `nil`.
+class Evilution::Mutator::Operator::RationalLiteral < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
+  def visit_rational_node(node)
+    replacements_for(node.value).each { |value| add_mutation_with_replacement(node, literal_for(value)) }
+    add_mutation_with_replacement(node, "nil")
+
+    super
+  end
+
+  # A complex literal (`3ri`) is replaced as a whole by ComplexLiteral. Its
+  # rational part is not a literal of its own: `nili` is not a value.
+  def visit_imaginary_node(_node); end
+
+  private
+
+  def replacements_for(value)
+    [0r, 1r, value + 1, value - 1].uniq - [value]
+  end
+
+  # A rational literal is an integer or a decimal, so its value and both
+  # neighbours always have a finite decimal form.
+  def literal_for(value)
+    return "#{value.numerator}r" if value.denominator == 1
+
+    digits = (1..).find { |count| ((10**count) % value.denominator).zero? }
+    whole, fraction = (value.abs * (10**digits)).to_i.divmod(10**digits)
+    "#{"-" if value.negative?}#{whole}.#{fraction.to_s.rjust(digits, "0")}r"
+  end
+
+  def add_mutation_with_replacement(node, replacement)
+    add_mutation(offset: node.location.start_offset, length: node.location.length, replacement:, node:)
+  end
+end

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

@@ -39,7 +39,7 @@ class Evilution::Mutator::Operator::ReduceToSum < Evilution::Mutator::Base
   # The arguments besides the `+` operand — at most an initial value — when
   # the call is a `+` reduction; nil otherwise.
   def initial_arguments(node)
-    arguments = node.arguments ? node.arguments.arguments : []
+    arguments = argument_nodes(node)
 
     if plus_block_pass?(node.block)
       arguments unless plus_symbol?(arguments.last)

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