saboteur 0.3.0 → 0.5.0

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,
@@ -59,14 +61,14 @@ module Saboteur
       def run_all(recorder)
         configuration.order = "rand:#{config.fetch('seed', 1)}"
         configuration.fail_fast = false
-        execute(Listener.new(recorder))
+        execute(Listener.new(recorder), log_phase: true)
       end
 
       def run_baseline(seed:)
         configuration.order = "rand:#{seed}"
         configuration.fail_fast = false
         listener = Listener.new
-        passed = execute(listener)
+        passed = execute(listener, log_phase: true)
         RunResult.new(passed: passed && listener.failed.empty?, failed_ids: listener.failed,
                       executed_ids: listener.executed, runtime: listener.runtime,
                       failure_classes: listener.failure_classes, failure_messages: listener.failure_messages)
@@ -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
@@ -104,11 +124,19 @@ module Saboteur
         world.example_groups.flat_map(&:descendants).each(&:reset_memoized)
       end
 
-      def execute(listener)
+      # log_phase is for the baseline and coverage children, whose $stdout is
+      # redirected to the phase's log: progress and failure detail land in
+      # that log, so a failed phase can be diagnosed from it. Mutant runs
+      # stay quiet.
+      def execute(listener, log_phase: false)
         reporter = ::RSpec::Core::Reporter.new(configuration)
         reporter.register_listener(listener, *Listener::EVENTS)
         groups = world.ordered_example_groups.select { |group| group.descendant_filtered_examples.any? }
         count = world.example_count(groups)
+        if log_phase
+          logger = PhaseLogger.new($stdout, total: count)
+          reporter.register_listener(logger, *PhaseLogger::EVENTS)
+        end
         started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         passed = reporter.report(count) do |r|
           configuration.with_suite_hooks { groups.map { |group| group.run(r) }.all? }
@@ -117,6 +145,42 @@ module Saboteur
         passed && !world.non_example_failure
       end
 
+      # Progress and failure detail for a phase log. Every 25 finished
+      # examples is enough to see movement on a tail; failures print RSpec's
+      # full formatted detail, and the run ends with RSpec's totals line.
+      class PhaseLogger
+        EVENTS = %i[example_finished message dump_failures dump_summary].freeze
+
+        PROGRESS_EVERY = 25
+
+        def initialize(out, total:)
+          @out = out
+          @total = total
+          @executed = 0
+        end
+
+        def example_finished(_notification)
+          @executed += 1
+          return unless @executed == @total || (@executed % PROGRESS_EVERY).zero?
+
+          @out.puts("#{@executed}/#{@total} examples finished")
+        end
+
+        # A failure outside any example (a suite hook, a load error) arrives
+        # as a message, never in dump_failures.
+        def message(notification)
+          @out.puts(notification.message)
+        end
+
+        def dump_failures(notification)
+          @out.puts(notification.fully_formatted_failed_examples)
+        end
+
+        def dump_summary(notification)
+          @out.puts(notification.totals_line)
+        end
+      end
+
       class Listener
         EVENTS = %i[example_started example_finished example_failed].freeze
 

data/lib/saboteur/mutation_source/argument_removal.rb

@@ -0,0 +1,86 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+
+module Saboteur
+  module MutationSource
+    # Deletes one ordinary argument from a parenthesized method call.
+    class ArgumentRemoval < Base
+      BOUNDARIES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode,
+                    Prism::ParametersNode, Prism::BlockParametersNode].freeze
+      EXCLUDED = [Prism::KeywordHashNode, Prism::SplatNode, Prism::ForwardingArgumentsNode].freeze
+
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "argument_removal"
+      end
+
+      def mutations_for(subject)
+        found = []
+        tokens = Prism.lex(subject.file_source).value.map(&:first)
+        visit(subject.node.body, subject, found, tokens)
+        found
+      end
+
+      private
+
+      def visit(node, subject, found, tokens)
+        return if node.nil? || BOUNDARIES.any? { |type| node.is_a?(type) }
+
+        if node.is_a?(Prism::StatementsNode)
+          node.body.each do |child|
+            visit(child, subject, found, tokens) unless @arid.any? do |p|
+              p.match?(child.slice)
+            end
+          end
+          return
+        end
+        remove_arguments(node, subject, found, tokens) if node.is_a?(Prism::CallNode)
+        node.compact_child_nodes.each { |child| visit(child, subject, found, tokens) }
+      end
+
+      def remove_arguments(node, subject, found, tokens)
+        return unless node.opening_loc&.slice == "(" && node.arguments
+
+        arguments = node.arguments.arguments
+        arguments.each_with_index do |argument, index|
+          next if EXCLUDED.any? { |type| argument.is_a?(type) } || heredoc?(argument)
+
+          separator = separator_for(node, arguments, index, tokens)
+          edits = [delete(subject, argument.location)]
+          edits << delete(subject, separator) if separator
+          found << Mutation.new(subject_id: subject.id, operator: name, edits: edits, source: name)
+        end
+      end
+
+      def separator_for(node, arguments, index, tokens)
+        argument = arguments[index]
+        after = comma_between(argument.location.end_offset, node.closing_loc.start_offset, tokens)
+        return after if after
+
+        previous = arguments[0...index].last
+        comma_between(previous.location.end_offset, argument.location.start_offset, tokens) if previous
+      end
+
+      def comma_between(first, last, tokens)
+        tokens.find do |token|
+          token.type == :COMMA && token.location.start_offset >= first && token.location.end_offset <= last
+        end&.location
+      end
+
+      def heredoc?(node)
+        (node.respond_to?(:opening_loc) && node.opening_loc&.slice&.start_with?("<<")) ||
+          node.compact_child_nodes.any? { |child| heredoc?(child) }
+      end
+
+      def delete(subject, location)
+        Edit.new(file: subject.file, start_byte: location.start_offset, end_byte: location.end_offset, replacement: "")
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/builtin.rb

@@ -5,6 +5,14 @@ require "prism"
 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
@@ -13,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
@@ -45,11 +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
@@ -64,6 +80,14 @@ module Saboteur
         visit(body)
         @found.concat(@filter_replacement.mutations_for(subject))
         @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
@@ -91,8 +115,8 @@ module Saboteur
       end
 
       # A raise that the method's own rescue catches is absorbed by design. It
-      # would survive, and a surviving coarse mutant stops every fine mutant
-      # of the method, so it is not generated.
+      # is not generated: rejecting that exception is not the rescue contract.
+      # Fine mutants still run regardless of the coarse verdicts.
       def rescues_everything?(body)
         clause = body.is_a?(Prism::BeginNode) ? body.rescue_clause : nil
         while clause
@@ -128,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

data/lib/saboteur/mutation_source/endpoint_replacement.rb

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+
+module Saboteur
+  module MutationSource
+    # Swaps the selected end of an explicitly received collection.
+    # Only message bytes change; arguments, receiver and block stay intact.
+    class EndpointReplacement < Base
+      REPLACEMENTS = { first: "last", last: "first" }.freeze
+      SCOPE_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+
+      # Base inherits Object's empty initializer; there is no parent state to set.
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "endpoint_replacement"
+      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) }
+
+        if node.is_a?(Prism::StatementsNode)
+          node.body.each { |statement| visit(statement, subject, found) unless arid?(statement) }
+          return
+        end
+
+        replace_endpoint(node, subject, found) if node.is_a?(Prism::CallNode)
+        node.compact_child_nodes.each { |child| visit(child, subject, found) }
+      end
+
+      def replace_endpoint(node, subject, found)
+        replacement = REPLACEMENTS[node.name]
+        return unless replacement && node.receiver
+        return if node.block
+        return unless node.arguments.nil?
+
+        location = node.message_loc
+        edit = Edit.new(file: subject.file, start_byte: location.start_offset,
+                        end_byte: location.end_offset, replacement: replacement)
+        found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+      end
+
+      def arid?(node)
+        @arid.any? { |pattern| pattern.match?(node.slice) }
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/hazard_guard.rb

@@ -0,0 +1,136 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module MutationSource
+    # Suppresses mutants that would run a destructive call with altered
+    # inputs. A mutant is only kept when every edit is provably safe: either
+    # the subject holds no hazardous call, or the edit removes every
+    # hazardous call in the method AND its replacement introduces no new one
+    # (checked by parsing the replacement, never by substring match). Edits
+    # strictly inside a call, edits elsewhere in a method that contains a
+    # call, and edits whose replacement re-includes a hazard (for example
+    # removing a negation in front of `system(...)`, or swapping
+    # `rm_rf("build")` for `rm_rf(".")`) all leave a destructive call
+    # running with altered inputs and are suppressed (issue #102).
+    class HazardGuard
+      # "<Receiver>.<name>" for calls with a receiver, the bare name for
+      # Kernel-style calls. Bare FileUtils operations are listed too, so an
+      # `include FileUtils` does not disarm the guard. Any method on Open3,
+      # any rmtree, and backticks/%x literals are always hazardous. Replace
+      # or extend via c.hazard; run them anyway with --allow-hazardous.
+      DEFAULT_HAZARD = [
+        "FileUtils.rm", "FileUtils.rm_r", "FileUtils.rm_rf", "FileUtils.rm_f",
+        "FileUtils.remove_dir", "FileUtils.remove_entry", "FileUtils.remove_entry_secure",
+        "rm", "rm_r", "rm_rf", "rm_f", "remove_dir", "remove_entry", "remove_entry_secure",
+        "File.delete", "File.unlink",
+        "Dir.rmdir", "Dir.delete", "Dir.unlink",
+        "IO.popen",
+        "Process.spawn", "Process.exec",
+        "system", "exec", "spawn", "`"
+      ].freeze
+
+      OPEN3 = /\A(::)?Open3\z/
+      ALWAYS_NAMES = %w[rmtree].freeze
+      KERNEL_RECEIVERS = %w[Kernel Process].freeze
+
+      def initialize(patterns = DEFAULT_HAZARD)
+        @tags = Set.new(patterns.map { |pattern| pattern.to_s.sub(/\A::/, "") })
+      end
+
+      def name
+        "hazard_guard"
+      end
+
+      # candidates: [[mutation, mutated_text]]. Returns [kept, suppressed].
+      def partition(candidates, subject)
+        spans = hazard_spans(subject.node)
+        return [candidates, []] if spans.empty?
+
+        candidates.partition { |mutation, _| safe?(mutation, spans) }
+      end
+
+      private
+
+      # Byte spans of hazardous calls in the node tree, with the source slice
+      # of each. Inner calls are covered by the outer span, so the walk does
+      # not descend into a hazardous call.
+      def hazard_spans(root)
+        spans = []
+        stack = [root]
+        until stack.empty?
+          node = stack.pop
+          if hazardous?(node)
+            spans << [node.location.start_offset, node.location.end_offset, node.slice]
+            next
+          end
+          stack.concat(node.compact_child_nodes)
+        end
+        spans
+      end
+
+      def hazardous?(node)
+        case node
+        when Prism::XStringNode, Prism::InterpolatedXStringNode then true
+        when Prism::CallNode then hazardous_call?(node)
+        else false
+        end
+      end
+
+      def hazardous_call?(node)
+        name = node.name.to_s
+        receiver = node.receiver&.slice&.sub(/\A::/, "")
+        return true if OPEN3.match?(receiver.to_s)
+        return true if ALWAYS_NAMES.include?(name)
+
+        tag = receiver ? "#{receiver}.#{name}" : name
+        return true if @tags.include?(tag)
+        # Kernel.system / Kernel.spawn / Process.spawn: the explicit-receiver
+        # spelling of a bare process spawn is the same hazard.
+        return true if KERNEL_RECEIVERS.include?(receiver) && @tags.include?(name)
+
+        piped_open?(node, name, receiver)
+      end
+
+      # Kernel#open with a "| command" argument spawns a process.
+      def piped_open?(node, name, receiver)
+        return false unless name == "open" && (receiver.nil? || receiver == "Kernel")
+
+        first = node.arguments&.arguments&.first
+        case first
+        when Prism::StringNode then first.unescaped.start_with?("|")
+        when Prism::InterpolatedStringNode
+          part = first.parts.first
+          part.is_a?(Prism::StringNode) && part.unescaped.start_with?("|")
+        else false
+        end
+      end
+
+      # A mutation is safe only while no hazardous call survives it: every
+      # edit must destroy every span (cover it wholly with a hazard-free
+      # replacement). Anything less - touching a call, or editing other
+      # code in a method that still holds a call - keeps the call running
+      # with altered inputs, so the mutant is suppressed.
+      def safe?(mutation, spans)
+        mutation.edits.all? { |edit| destroys_all?(edit, spans) }
+      end
+
+      def destroys_all?(edit, spans)
+        spans.all? do |start_byte, end_byte, _slice|
+          edit.start_byte <= start_byte && edit.end_byte >= end_byte
+        end && replacement_clean?(edit.replacement)
+      end
+
+      # The replacement itself, parsed as code. A replacement that parses
+      # and contains no hazardous call cannot run one; anything else -
+      # a hazard in the new text, or text that does not parse on its own -
+      # is treated as hazardous.
+      def replacement_clean?(replacement)
+        result = Prism.parse(replacement.to_s)
+        return false unless result.success?
+
+        hazard_spans(result.value).empty?
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/operator_assignment.rb

@@ -0,0 +1,52 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Saboteur
+  module MutationSource
+    # Changes the arithmetic operation, without changing the assignment target.
+    class OperatorAssignment < Base
+      REPLACEMENTS = { :+ => "-=", :- => "+=", :* => "/=", :/ => "*=" }.freeze
+      WRITE_NODES = [Prism::LocalVariableOperatorWriteNode, Prism::InstanceVariableOperatorWriteNode,
+                     Prism::ClassVariableOperatorWriteNode, Prism::GlobalVariableOperatorWriteNode,
+                     Prism::ConstantOperatorWriteNode, Prism::ConstantPathOperatorWriteNode,
+                     Prism::CallOperatorWriteNode, Prism::IndexOperatorWriteNode].freeze
+      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
+        "operator_assignment"
+      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) }
+
+        replace(node, subject, found) if WRITE_NODES.any? { |type| node.is_a?(type) }
+        node.compact_child_nodes.each { |child| visit(child, subject, found) }
+      end
+
+      def replace(node, subject, found)
+        replacement = REPLACEMENTS[node.binary_operator]
+        return unless replacement
+
+        location = node.binary_operator_loc
+        edit = Edit.new(file: subject.file, start_byte: location.start_offset,
+                        end_byte: location.end_offset, replacement: replacement)
+        found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+      end
+    end
+  end
+end