saboteur 0.4.0 → 0.5.0

data/lib/saboteur/execution/worker_pool.rb

@@ -30,9 +30,10 @@ module Saboteur
 
       # on_start: called in each worker with its number before its first
       # item (per-worker database connections, for example).
-      def initialize(jobs:, on_start: nil)
+      def initialize(jobs:, on_start: nil, on_result: nil)
         @jobs = jobs
         @on_start = on_start
+        @on_result = on_result
         @start_failures = 0
       end
 
@@ -78,13 +79,22 @@ module Saboteur
       # next item, retires it when none is left, or replaces it if it died.
       def receive(worker, workers, queue, results, items, &)
         line = worker.results.gets
-        take(worker, line, results) if line
+        take_and_report(worker, line, results) if line
         return replace(worker, workers, queue, results, items, &) if line.nil? || worker.last_words
 
         assign(worker, queue)
         retire(worker, workers) unless worker.current
       end
 
+      # Records one result line, then reports the arrival before the worker
+      # gets more work: a watcher (the canary) can raise here and stop every
+      # queued item from starting (issue #102).
+      def take_and_report(worker, line, results)
+        current = worker.current
+        take(worker, line, results)
+        @on_result&.call(current, results[current]) if current && results[current]
+      end
+
       def parse(line)
         JSON.parse(line)
       rescue JSON::ParserError => e
@@ -112,7 +122,7 @@ module Saboteur
         pending = worker.results.read_nonblock(1 << 20, exception: false)
         return unless pending.is_a?(String)
 
-        pending.each_line { |line| take(worker, line, results) if line.end_with?("\n") }
+        pending.each_line { |line| take_and_report(worker, line, results) if line.end_with?("\n") }
       rescue IOError
         nil
       end
@@ -121,7 +131,13 @@ module Saboteur
         drain(worker, results)
         retire(worker, workers)
         reason = worker.last_words || "worker #{worker.number} died#{how(worker.status)}"
-        results[worker.current] = { "error" => "#{reason}, running this item" } if worker.current
+        if worker.current
+          # The synthetic error row takes the same arrival path as a normal
+          # result, so the canary still trips when the dead worker damaged
+          # the tree before dying (issue #102).
+          results[worker.current] = { "error" => "#{reason}, running this item" }
+          @on_result&.call(worker.current, results[worker.current])
+        end
         give_up(reason) if worker.done.zero?
         return if queue.empty?
 

data/lib/saboteur/execution/wrapper.rb

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Execution
+    # Registry of gems that wrap a method at definition time. Their wrapper
+    # is what Ruby runs, so the shadow guard would call every wrapped method
+    # "shadowed" and skip it. A registered wrapper is instead recognized and
+    # re-evaluated together with the def (see Scheduler#eval_prefix). An
+    # unknown wrapper still hits the generic guard, which is the safe side.
+    module Wrapper
+      # :sorbet when the runtime method is sorbet-runtime's sig wrapper:
+      # its source lives inside the gem and a signature is registered for it.
+      def self.around(method, file)
+        return nil unless file&.include?("sorbet-runtime")
+        return nil unless defined?(::T::Utils) && ::T::Utils.respond_to?(:signature_for_method)
+        return nil unless ::T::Utils.signature_for_method(method)
+
+        :sorbet
+      rescue StandardError
+        nil
+      end
+
+      # The def a wrapper dispatches to: sorbet's runtime method is a
+      # forwarding wrapper, while the registered signature holds the real
+      # def. Callers comparing definitions (StaleCaptures) must compare
+      # against this, or the freshly re-registered def reads as stale.
+      # Real sorbet returns a Signature object (its #method is the def);
+      # minimal registries return the method itself. Nil when unknown.
+      def self.original_def(method)
+        return nil unless around(method, method.source_location&.first) == :sorbet
+
+        registered = ::T::Utils.signature_for_method(method)
+        candidate = if registered.is_a?(Method) || registered.is_a?(UnboundMethod)
+                      registered
+                    elsif registered.respond_to?(:method)
+                      registered.method
+                    end
+        candidate.is_a?(Method) || candidate.is_a?(UnboundMethod) ? candidate : nil
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/saboteur/gates.rb

@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  # CI gates on how many mutants ended as a timeout or an error. A limit is a
+  # count ("3") or a percentage of the executed mutants ("5%"); the gate fails
+  # only when the count is above it. Unset means no gate.
+  class Gates
+    Violation = Data.define(:cause, :message)
+
+    # config key => [mutant status, exit cause recorded in the JSON report, flag]
+    SETTINGS = {
+      "max_timeouts" => [:timeout, "maxTimeouts", "--max-timeouts"],
+      "max_errors" => [:error, "maxErrors", "--max-errors"]
+    }.freeze
+    LIMIT = /\A(\d+)(%?)\z/
+
+    # The normalized limit: nil, an Integer count, or a String ending in "%".
+    # A malformed value is a ConfigError that names the setting.
+    def self.limit(value, key)
+      return nil if value.nil?
+
+      match = LIMIT.match(value.to_s.strip)
+      raise ConfigError, "#{key} must be a count (3) or a percentage (5%), got #{value.inspect}" unless match
+
+      digits, suffix = match.captures
+      number = digits.to_i
+      raise ConfigError, "#{key} percentage must be at most 100" if suffix == "%" && number > 100
+
+      suffix.empty? ? number : "#{number}%"
+    end
+
+    # The --max-timeouts and --max-errors flags; each value goes to the block with its config key.
+    def self.define_options(parser)
+      SETTINGS.each do |key, (status, _cause, flag)|
+        parser.on("#{flag} N", "Exit 1 when more than N mutants end as #{status} (N or N%)") do |value|
+          yield key.to_sym, value
+        end
+      end
+    end
+
+    def initialize(config)
+      @limits = SETTINGS.keys.to_h { |key| [key, self.class.limit(config[key], key)] }
+    end
+
+    attr_reader :cause
+
+    def any?
+      @limits.values.any?
+    end
+
+    # --max-errors judges errored mutants, so a threshold run tolerates them.
+    def judges_errors?
+      !@limits.fetch("max_errors").nil?
+    end
+
+    # Prints each failed gate to err and remembers the first one's cause for the JSON report.
+    def failed?(report, err)
+      found = violations(report)
+      found.each { |violation| err.puts("saboteur: #{violation.message}") }
+      @cause = found.first&.cause
+      !@cause.nil?
+    end
+
+    def violations(report)
+      SETTINGS.filter_map do |key, (status, cause, flag)|
+        limit = @limits.fetch(key)
+        count = report.counts.fetch(status)
+        next if limit.nil? || !over?(count, limit, report.executed.size)
+
+        Violation.new(cause: cause, message: "#{count} #{status} mutants, above #{flag} #{limit}")
+      end
+    end
+
+    private
+
+    def over?(count, limit, executed)
+      return count > limit if limit.is_a?(Integer)
+
+      count * 100 > limit.to_i * executed
+    end
+  end
+end

data/lib/saboteur/help.rb

@@ -21,7 +21,7 @@ module Saboteur
            "errored. With --threshold: the score is at or above it, even if mutants survived.",
       1 => "Without --threshold: at least one mutant survived and is not on the ignore list. With --threshold " \
            "(survivors alone no longer fail the run): the score is below it, or no mutant was tested so " \
-           "there is no score.",
+           "there is no score. Also more timeout or errored mutants than --max-timeouts or --max-errors allow.",
       2 => "Usage or configuration error: fix the command or config/saboteur.rb. A replay --id that matches no " \
            "mutant is only found after the target has booted. A named source or test file that does not exist.",
       3 => "Tool error: saboteur could not finish, or more than half of the executed mutants errored (such " \
@@ -42,7 +42,8 @@ module Saboteur
                      "tests that cover each change, and reports survivors (changes no test noticed). Source files or " \
                      "directories after run replace include and exclude; --test limits the specs that run; " \
                      "--threshold PERCENT replaces the survivor check: exit 0 when the score is at or above " \
-                     "PERCENT, exit 1 when it is below.",
+                     "PERCENT, exit 1 when it is below. Inline comment syntax: " \
+                     '# saboteur:disable-line [operator ...] reason="...". A reason is required.',
         takes_options: true,
         exit_codes: EXIT_CODE_MEANINGS,
         examples: [
@@ -58,14 +59,37 @@ module Saboteur
       ),
       Command.new(
         name: "doctor",
-        summary: "Check the environment and run the baseline twice, without mutating anything",
-        description: "Boots the target like a run, checks runtime, coverage and boot files, then runs your " \
-                     "suite twice in the same order with one seed and reports whether both runs passed. " \
-                     "It never mutates anything.",
+        summary: "Check the environment, and with --suite run the baseline twice, without mutating anything",
+        description: "Boots the target like a run and checks runtime, coverage and boot files. With --suite " \
+                     "it also runs your suite twice in the same order with one seed and reports whether both " \
+                     "runs passed; --test PATH limits those runs to some specs. It never mutates anything.",
         takes_options: true,
         exit_codes: DOCTOR_EXIT_CODE_MEANINGS,
         examples: [["Check the setup before the first run", "saboteur doctor"],
-                   ["Use another config file and seed", "saboteur doctor --config config/ci.rb --seed 7"]]
+                   ["Also run the unchanged suite twice", "saboteur doctor --suite --seed 7"],
+                   ["Run only some specs twice", "saboteur doctor --test spec/models"]]
+      ),
+      Command.new(
+        name: "baseline",
+        summary: "Check, propose or accept a fresh opt-in survivor baseline",
+        description: "Check runs every mutant fresh and reports new, changed or unmatched accepted survivors. " \
+                     "Propose writes a proposal with private local execution evidence. Edit only survivor reasons; " \
+                     "accept verifies current inputs and publishes it. No scores or execution are suppressed. " \
+                     "With --epsilon POINTS, check also fails when the score drops more than POINTS percentage " \
+                     "points below the accepted baseline's score. " \
+                     "Only whole or subject scope; no diff, replay, incremental reuse or score threshold.",
+        takes_options: true,
+        exit_codes: { 0 => "Clean check, proposal written or accepted.",
+                      1 => "New, changed or unmatched survivors, or a score drop beyond --epsilon.",
+                      2 => "Invalid configuration, incompatible baseline or rejected acceptance.",
+                      3 => "Incomplete execution or tool failure." },
+        examples: [["Prepare a reasoned proposal",
+                    "saboteur baseline propose --baseline baseline.json --proposal proposal.json"],
+                   ["Publish reviewed reasons",
+                    "saboteur baseline accept --baseline baseline.json --proposal proposal.json"],
+                   ["Check fresh outcomes", "saboteur baseline check --baseline baseline.json"],
+                   ["Also fail on a score drop of more than 2 points",
+                    "saboteur baseline check --baseline baseline.json --epsilon 2"]]
       ),
       Command.new(
         name: "version",

data/lib/saboteur/ignore_list.rb

@@ -96,6 +96,11 @@ module Saboteur
       @index = entries.to_h { |entry| [[entry.subject, entry.mutation], entry] }
     end
 
+    # True when this result is a survivor the list accepts.
+    def accepts?(result)
+      result.survived? && @index.key?([result.subject.id, result.digest])
+    end
+
     # Marks matching survivors as ignored. Returns warnings for stale entries:
     # entries whose subject was examined but whose mutation no longer exists.
     def apply(results)

data/lib/saboteur/inline_suppression.rb

@@ -0,0 +1,65 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require "shellwords"
+require_relative "mutation_source/operator_registry"
+
+module Saboteur
+  # Only real Ruby comments can suppress edits, never text inside a string.
+  class InlineSuppression
+    Directive = Data.define(:line, :operators, :reason)
+
+    def initialize(file, source)
+      @file = file
+      @directives = Prism.parse(source).comments.filter_map { |comment| parse(comment) }
+    end
+
+    # Preserve ordinary comment/formatting skips, but treat directives as
+    # selection inputs. Relative lines distinguish which code they suppress.
+    def signature(subject)
+      @directives.select { |entry| subject.contains_line?(entry.line) }.map do |entry|
+        [entry.line - subject.start_line, entry.operators.sort, entry.reason]
+      end
+    end
+
+    def reason(subject, mutation)
+      mutation.edits.each do |edit|
+        line = subject.line_of(edit.start_byte)
+        directive = @directives.find do |entry|
+          entry.line == line && (entry.operators.empty? || entry.operators.include?(mutation.operator))
+        end
+        return directive if directive
+      end
+      nil
+    end
+
+    private
+
+    def parse(comment)
+      text = comment.location.slice.sub(/\A#\s*/, "")
+      return nil unless text.start_with?("saboteur:disable-line")
+
+      line = comment.location.start_line
+      tokens = Shellwords.split(text)
+      fail_at(line, "expected saboteur:disable-line") unless tokens.shift == "saboteur:disable-line"
+      reasons, operators = tokens.partition { |token| token.start_with?("reason=") }
+      reason, = reasons
+      fail_at(line, "one nonblank reason=\"...\" is required") unless
+        reasons.size == 1 && !reason.delete_prefix("reason=").strip.empty?
+      validate_operators(operators, line)
+      Directive.new(line: line, operators: operators, reason: reason.delete_prefix("reason="))
+    rescue ArgumentError => e
+      fail_at(line, "invalid suppression: #{e.message}")
+    end
+
+    def validate_operators(operators, line)
+      unknown = operators - MutationSource::OperatorRegistry::DESCRIPTIONS.keys
+      fail_at(line, "unknown operators: #{unknown.join(', ')}") unless unknown.empty?
+    end
+
+    def fail_at(line, message)
+      raise ConfigError, "#{@file}:#{line}: #{message}"
+    end
+  end
+end

data/lib/saboteur/integration/base.rb

@@ -77,4 +77,5 @@ module Saboteur
   end
 end
 
+require_relative "focus_guard"
 require_relative "rspec"

data/lib/saboteur/integration/focus_guard.rb

@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Integration
+    # Refuses a suite that a focus filter has narrowed without the user asking
+    # for it. With `filter_run_when_matching :focus`, one stray `fit` makes
+    # RSpec skip every other example. The baseline stays green and the score
+    # then describes only the focused examples, with no sign that the rest
+    # never ran.
+    #
+    # The test is a difference of two selections, both made by RSpec's own
+    # FilterManager#prune: the examples that run now, and the examples that
+    # would run if the stray focus rule were absent. Everything else RSpec
+    # decides stays the same in both, so it never counts as hidden: example
+    # selectors (`spec/a_spec.rb:12`) and their file-scoped priority,
+    # `--tag` filters named in rspec_args, exclusions, and the :if / :unless
+    # pruning of conditional examples.
+    class FocusGuard
+      LOCATION_KEYS = %i[locations ids].freeze
+
+      def initialize(world:, explicit_filter_keys:)
+        @world = world
+        @explicit_filter_keys = explicit_filter_keys
+      end
+
+      # Raises ConfigError naming the focused examples when the focus filter
+      # hides examples that would otherwise run.
+      def check!
+        return if stray_rules.empty?
+        return if hidden_examples.empty?
+
+        raise ConfigError, message
+      end
+
+      private
+
+      attr_reader :world
+
+      def filter_manager
+        world.filter_manager
+      end
+
+      # Inclusion rules the suite added itself, such as the :focus rule that
+      # `filter_run_when_matching :focus` installs once a fit exists.
+      def stray_rules
+        @stray_rules ||= begin
+          rules = filter_manager.inclusions.rules
+          rules.slice(*(rules.keys - LOCATION_KEYS - @explicit_filter_keys))
+        end
+      end
+
+      def running_examples
+        @running_examples ||= filter_manager.prune(world.all_examples)
+      end
+
+      # The selection RSpec would make without the stray rules.
+      def examples_without_stray_focus
+        manager = ::RSpec::Core::FilterManager.new
+        manager.exclusions.rules.replace(filter_manager.exclusions.rules)
+        manager.inclusions.rules.replace(filter_manager.inclusions.rules.except(*stray_rules.keys))
+        manager.prune(world.all_examples)
+      end
+
+      def hidden_examples
+        @hidden_examples ||= examples_without_stray_focus - running_examples
+      end
+
+      def focused_examples
+        focus = ::RSpec::Core::FilterRules.new(stray_rules)
+        running_examples.select { |example| focus.include_example?(example) }
+      end
+
+      def message
+        total = hidden_examples.size + running_examples.size
+        locations = focused_examples.map(&:location).uniq.first(5).join(", ")
+        "a focus filter (#{::RSpec::Core::FilterRules.new(stray_rules).description}) narrowed the suite: " \
+          "#{hidden_examples.size} of #{total} examples would not run, so the score would cover only the " \
+          "ones that do (#{locations}). Remove the focus, or pass --allow-focus to run the narrowed suite anyway."
+      end
+    end
+  end
+end

data/lib/saboteur/integration/rspec.rb

@@ -14,6 +14,8 @@ module Saboteur
         @runner.setup($stderr, $stdout)
         configuration.order = "rand:#{config.fetch('seed', 1)}"
         raise Error, "rspec quit while loading spec files" if world.wants_to_quit
+
+        refuse_unintended_focus
       end
 
       # RSpec only adds its default "spec" path when $0 is `rspec`.
@@ -48,7 +50,7 @@ module Saboteur
         wanted = Set.new(ids)
         narrow_to(wanted)
         order_by(ids)
-        configuration.fail_fast = 1
+        configuration.fail_fast = config["matrix"] ? false : 1
         listener = Listener.new
         passed = execute(listener)
         RunResult.new(passed: passed && listener.failed.empty?, failed_ids: listener.failed,
@@ -74,6 +76,24 @@ module Saboteur
 
       private
 
+      def refuse_unintended_focus
+        return if config["allow_focus"]
+
+        FocusGuard.new(world:, explicit_filter_keys: explicit_inclusion_keys).check!
+      end
+
+      # Inclusion filters the user named in rspec_args or .rspec, such as
+      # `--tag slow`. Those narrow the run on purpose.
+      def explicit_inclusion_keys
+        options = configuration_options
+        filter_manager = ::RSpec::Core::FilterManager.new
+        options.configure_filter_manager(filter_manager)
+        keys = filter_manager.inclusions.rules.keys
+        # `--example TEXT` becomes a :full_description rule when the options
+        # reach the configuration, not in the filter manager.
+        options.options[:full_description] ? keys + [:full_description] : keys
+      end
+
       def world
         ::RSpec.world
       end

data/lib/saboteur/mutation_source/builtin.rb

@@ -6,7 +6,13 @@ require_relative "base"
 require_relative "filter_replacement"
 require_relative "literal_replacement"
 require_relative "argument_removal"
+require_relative "chain_removal"
 require_relative "pair_removal"
+require_relative "endpoint_replacement"
+require_relative "operator_registry"
+require_relative "range_replacement"
+require_relative "operator_assignment"
+require_relative "condition_negation"
 
 module Saboteur
   module MutationSource
@@ -15,7 +21,7 @@ module Saboteur
     class Builtin < Base
       DEFAULT_ARID = [
         '\A(puts|pp|p|print|warn)\b',
-        '\A(::)?(Rails\.)?logger\b',
+        '\A(@|self\.|::)?(Rails\.)?logger\b',
         '\A(::)?(StatsD|Statsd|Datadog|NewRelic)\b',
         '\.instrument\b'
       ].freeze
@@ -47,13 +53,19 @@ module Saboteur
       CATCH_ALL = %w[StandardError ::StandardError Exception ::Exception].freeze
       SCOPE_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
 
-      def initialize(arid: DEFAULT_ARID)
+      def initialize(arid: DEFAULT_ARID, operators: [])
         super()
+        @operators = OperatorRegistry.resolve(operators)
         @arid = arid.map { |pattern| pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern) }
         @filter_replacement = FilterReplacement.new(arid: arid)
         @literal_replacement = LiteralReplacement.new(arid: arid)
         @argument_removal = ArgumentRemoval.new(arid: arid)
         @pair_removal = PairRemoval.new(arid: arid)
+        @chain_removal = ChainRemoval.new(arid: arid)
+        @endpoint_replacement = EndpointReplacement.new(arid: arid)
+        @range_replacement = RangeReplacement.new(arid: arid)
+        @operator_assignment = OperatorAssignment.new(arid: arid)
+        @condition_negation = ConditionNegation.new(arid: arid)
       end
 
       def name
@@ -70,6 +82,12 @@ module Saboteur
         @found.concat(@literal_replacement.mutations_for(subject))
         @found.concat(@argument_removal.mutations_for(subject))
         @found.concat(@pair_removal.mutations_for(subject))
+        @found.concat(@chain_removal.mutations_for(subject))
+        @found.concat(@endpoint_replacement.mutations_for(subject))
+        @found.concat(@range_replacement.mutations_for(subject))
+        @found.concat(@operator_assignment.mutations_for(subject))
+        @found.concat(@condition_negation.mutations_for(subject))
+        @found.select { |mutation| @operators.include?(mutation.operator) }
       ensure
         @subject = nil
       end
@@ -134,7 +152,8 @@ module Saboteur
         statements.each do |statement|
           next if arid?(statement)
 
-          add("statement_removal", statement, "nil") if statements.size > 1 && removable?(statement)
+          removable_here = statements.drop(1).any? && removable?(statement)
+          add("statement_removal", statement, "nil") if removable_here
           visit(statement)
         end
       end

data/lib/saboteur/mutation_source/chain_removal.rb

@@ -0,0 +1,80 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+
+module Saboteur
+  module MutationSource
+    # Drops one link from the middle of a method chain: a.b.c becomes a.c.
+    # The first receiver and the last call stay, so the result is still a call
+    # on the original object.
+    class ChainRemoval < Base
+      BOUNDARIES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+      # Links this operator leaves alone by design. They hand back their receiver or a
+      # copy of it (tap after running a block), so dropping one changes mutability,
+      # copying or a block's side effects. Tests can observe those, but they are other
+      # contracts than "a step in the query chain went missing", and removing them
+      # mostly yields noise, so they are out of scope here.
+      IDENTITY_CALLS = %w[freeze dup clone itself tap].freeze
+
+      # Targets of a write: `a.b.c = 1`, `a.b.c += 1`, `a.b[0] ||= 1`. The whole receiver chain
+      # is the thing being assigned to, so no link of it is dropped.
+      WRITE_NODES = [Prism::CallOperatorWriteNode, Prism::CallOrWriteNode, Prism::CallAndWriteNode,
+                     Prism::IndexOperatorWriteNode, Prism::IndexOrWriteNode, Prism::IndexAndWriteNode].freeze
+
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "chain_removal"
+      end
+
+      def mutations_for(subject)
+        found = []
+        visit(subject.node.body, subject, found)
+        found
+      end
+
+      private
+
+      def visit(node, subject, found)
+        return if node.nil? || BOUNDARIES.any? { |type| node.is_a?(type) }
+
+        if node.is_a?(Prism::StatementsNode)
+          node.body.each { |child| visit(child, subject, found) unless @arid.any? { |p| p.match?(child.slice) } }
+          return
+        end
+        remove_link(node, subject, found) if node.is_a?(Prism::CallNode)
+        children(node).each { |child| visit(child, subject, found) }
+      end
+
+      # Everything under the node except the receiver chain of a write target.
+      def children(node)
+        return node.compact_child_nodes unless write_target?(node)
+
+        node.compact_child_nodes.reject { |child| child.equal?(node.receiver) }
+      end
+
+      def write_target?(node)
+        WRITE_NODES.any? { |type| node.is_a?(type) } || (node.is_a?(Prism::CallNode) && node.attribute_write?)
+      end
+
+      def remove_link(call, subject, found)
+        link = call.receiver
+        return unless call.call_operator_loc && !call.attribute_write? && removable?(link)
+
+        edit = Edit.new(file: subject.file, start_byte: link.receiver.end_offset,
+                        end_byte: link.end_offset, replacement: "")
+        found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+      end
+
+      # A dotted call with a method name (a dot always has a receiver).
+      def removable?(link)
+        link.is_a?(Prism::CallNode) && link.call_operator_loc && link.message_loc &&
+          !IDENTITY_CALLS.include?(link.name.to_s)
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/condition_negation.rb

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Saboteur
+  module MutationSource
+    # Negates the predicate, retaining its evaluation and branch structure.
+    class ConditionNegation < Base
+      SCOPE_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "condition_negation"
+      end
+
+      def mutations_for(subject)
+        found = []
+        visit(subject.node.body, subject, found)
+        found
+      end
+
+      private
+
+      def visit(node, subject, found)
+        return if node.nil? || SCOPE_NODES.any? { |scope| node.is_a?(scope) }
+        return if @arid.any? { |pattern| pattern.match?(node.slice) }
+
+        negate(node.predicate, subject, found) if node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
+        node.compact_child_nodes.each { |child| visit(child, subject, found) }
+      end
+
+      def negate(predicate, subject, found)
+        # Existing true/false and negation-removal operators own these cases.
+        if predicate.is_a?(Prism::TrueNode) || predicate.is_a?(Prism::FalseNode) || predicate.is_a?(Prism::NilNode)
+          return
+        end
+        return if predicate.is_a?(Prism::CallNode) && predicate.name == :!
+
+        location = predicate.location
+        edit = Edit.new(file: subject.file, start_byte: location.start_offset,
+                        end_byte: location.end_offset, replacement: "!(#{predicate.slice})")
+        found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+      end
+    end
+  end
+end