evilution 1.3.0 → 1.4.0

data/lib/evilution/baseline/spec_failure.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../baseline"
+
+class Evilution::Baseline
+  ExampleFailure = Data.define(:id, :description, :message)
+
+  # Why one spec file was red in the baseline: the examples that failed, or the
+  # error that stopped it before any example could -- a load error, a runner
+  # that raised, a timeout. example_count is every failing example; examples
+  # holds only the first few, for display; failed_ids names all of them the
+  # way a mutation run does, for comparison.
+  SpecFailure = Data.define(:spec_file, :examples, :example_count, :error, :failed_ids) do
+    def self.from_report(spec_file, report)
+      examples = Array(report[:failures]).map { |failure| ExampleFailure.new(**failure) }
+      new(
+        spec_file: spec_file,
+        examples: examples,
+        example_count: report[:failure_count] || examples.length,
+        error: report[:error],
+        failed_ids: Array(report[:failed_ids])
+      )
+    end
+
+    def initialize(spec_file:, examples: [], example_count: 0, error: nil, failed_ids: [])
+      super
+    end
+
+    def to_h
+      {
+        spec_file: spec_file,
+        error: error,
+        failing_examples: example_count,
+        examples: examples.map(&:to_h)
+      }
+    end
+  end
+end

data/lib/evilution/baseline.rb

@@ -2,10 +2,11 @@
 
 require_relative "spec_resolver"
 require_relative "process_cleanup"
+require_relative "diagnostic"
 
 class Evilution::Baseline
-  Result = Struct.new(:failed_spec_files, :duration) do
-    def initialize(**)
+  Result = Struct.new(:failed_spec_files, :duration, :failures) do
+    def initialize(failed_spec_files:, duration:, failures: [])
       super
       freeze
     end
@@ -13,6 +14,11 @@ class Evilution::Baseline
     def failed?
       !failed_spec_files.empty?
     end
+
+    # Every example known to have failed before any mutation ran.
+    def failed_example_ids
+      failures.flat_map(&:failed_ids).to_set
+    end
   end
 
   # spec_selector: the object `run` resolves with (integration layout plus
@@ -37,18 +43,20 @@ class Evilution::Baseline
 
   def call(subjects)
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    spec_files = baseline_spec_files(subjects)
-    failed = Set.new
-
-    spec_files.each do |spec_file|
-      failed.add(spec_file) unless run_spec_file(spec_file)
-    end
+    failures = baseline_spec_files(subjects).filter_map { |spec_file| check_spec_file(spec_file) }
 
     duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-    Result.new(failed_spec_files: failed, duration: duration)
+    Result.new(failed_spec_files: failures.to_set(&:spec_file), duration: duration, failures: failures)
   end
 
   def run_spec_file(spec_file)
+    check_spec_file(spec_file).nil?
+  end
+
+  # nil when the spec file passed, otherwise why it did not. Anything that
+  # stops the baseline from getting an answer counts as failing, and is
+  # recorded as the reason.
+  def check_spec_file(spec_file)
     raise Evilution::Error, "no baseline runner configured" unless @runner
 
     read_io, write_io = IO.pipe
@@ -57,11 +65,11 @@ class Evilution::Baseline
     read_result(read_io, pid, spec_file)
   rescue Evilution::Error
     raise
-  rescue StandardError
-    false
+  rescue StandardError => e
+    warned(SpecFailure.new(spec_file: spec_file, error: "#{e.class}: #{e.message}"))
   ensure
-    read_io&.close
-    write_io&.close
+    read_io.close if read_io
+    write_io.close if write_io
   end
 
   def fork_spec_runner(spec_file, read_io, write_io)
@@ -71,32 +79,28 @@ class Evilution::Baseline
       $stdout.reopen(File::NULL, "w")
       $stderr.reopen(File::NULL, "w")
 
-      passed = runner.call(spec_file)
-      Marshal.dump({ passed: passed }, write_io)
+      report = child_report(runner, spec_file)
+      Marshal.dump(report, write_io)
       write_io.close
-      exit!(passed ? 0 : 1)
+      exit!(report[:passed] ? 0 : 1)
     end
   end
 
   GRACE_PERIOD = 0.5
 
   def read_result(read_io, pid, spec_file)
-    if read_io.wait_readable(@timeout)
-      data = read_io.read
-      Process.wait(pid)
-      return false if data.empty?
-
-      result = Marshal.load(data)
-      result[:passed]
-    else
-      terminate_child(pid)
-      warn_timeout(spec_file)
-      false
-    end
+    return timed_out(pid, spec_file) unless read_io.wait_readable(@timeout)
+
+    data = read_io.read
+    _, status = Process.wait2(pid)
+    return warned(SpecFailure.new(spec_file: spec_file, error: unreported_error(status))) if data.empty?
+
+    report = Marshal.load(data)
+    report[:passed] ? nil : warned(SpecFailure.from_report(spec_file, report))
   end
 
   def warn_timeout(spec_file)
-    warn "[evilution] Baseline for #{spec_file} timed out after #{@timeout}s; treating it as failing."
+    Evilution::Diagnostic.warn("[evilution] Baseline for #{spec_file} timed out after #{@timeout}s; treating it as failing.")
   end
 
   def terminate_child(pid)
@@ -114,6 +118,35 @@ class Evilution::Baseline
 
   private
 
+  # Runs in the child. A runner that raises -- a spec helper that cannot load,
+  # a framework that is not there -- is a failure with a reason, not a child
+  # that dies without a word.
+  def child_report(runner, spec_file)
+    Report.from(runner.call(spec_file))
+  rescue StandardError, ScriptError => e
+    Report.build(passed: false, error: "#{e.class}: #{e.message}")
+  end
+
+  def timed_out(pid, spec_file)
+    terminate_child(pid)
+    warn_timeout(spec_file)
+    SpecFailure.new(spec_file: spec_file, error: "timed out after #{@timeout}s")
+  end
+
+  def unreported_error(status)
+    cause = status.signaled? ? "signal #{status.termsig}" : "exit status #{status.exitstatus}"
+    "baseline process ended without reporting (#{cause})"
+  end
+
+  def warned(failure)
+    detail = FailureFormatter.new.call(failure).map { |line| "  #{line}" }
+    Evilution::Diagnostic.warn(
+      ["[evilution] Baseline failed for #{failure.spec_file}; " \
+       "a mutation that fails only its already-failing examples will be reported neutral.", *detail].join("\n")
+    )
+    failure
+  end
+
   def baseline_spec_files(subjects)
     return Array(@test_files).uniq if @test_files && !@test_files.empty?
 
@@ -137,7 +170,7 @@ class Evilution::Baseline
 
   def warn_no_matching_test(file_path)
     action = @fallback_to_full_suite ? "running full suite" : "marking its mutations unresolved"
-    warn "[evilution] No matching test found for #{file_path}, #{action}. #{no_match_hint(file_path)}"
+    Evilution::Diagnostic.warn("[evilution] No matching test found for #{file_path}, #{action}. #{no_match_hint(file_path)}")
   end
 
   def no_match_hint(file_path)
@@ -150,3 +183,7 @@ class Evilution::Baseline
     @fallback_to_full_suite ? "#{hint}." : "#{hint}, or --fallback-full-suite to run the whole suite."
   end
 end
+
+require_relative "baseline/report"
+require_relative "baseline/spec_failure"
+require_relative "baseline/failure_formatter"

data/lib/evilution/cli/parser/file_args.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../parser"
+require_relative "../../diagnostic"
 
 module Evilution::CLI::Parser::FileArgs
   ParsedPaths = Data.define(:files, :ranges)
@@ -24,7 +25,7 @@ module Evilution::CLI::Parser::FileArgs
 
   def expand_spec_dir(dir)
     unless File.directory?(dir)
-      warn("Error: #{dir} is not a directory")
+      Evilution::Diagnostic.warn("Error: #{dir} is not a directory")
       return []
     end
 

data/lib/evilution/cli/parser/options_builder.rb

@@ -140,7 +140,7 @@ class Evilution::CLI::Parser::OptionsBuilder
 
   def add_profile_options(opts)
     opts.on("--profile NAME", "Operator profile: default, strict (default: default). " \
-                              "strict adds aggressive truthiness mutators for pre-merge audits.") { |p| @options[:profile] = p }
+                              "strict adds aggressive mutators for pre-merge audits.") { |p| @options[:profile] = p }
     opts.on("--strict", "Shortcut for --profile=strict") { @options[:profile] = "strict" }
   end
 

data/lib/evilution/cli.rb

@@ -24,6 +24,7 @@ require_relative "cli/commands/session_gc"
 require_relative "cli/commands/compare"
 require_relative "cli/commands/run"
 require_relative "cli/exit_guard"
+require_relative "diagnostic"
 
 # @api private
 class Evilution::CLI
@@ -42,14 +43,14 @@ class Evilution::CLI
     return run_subcommand_error(@parse_error) if @command == :parse_error
 
     result = Dispatcher.lookup(@command).new(@parsed, stdout: $stdout, stderr: $stderr).call
-    warn("Error: #{result.error.message}") if result.error && !result.error_rendered
+    Evilution::Diagnostic.warn("Error: #{result.error.message}") if result.error && !result.error_rendered
     result.exit_code
   end
 
   private
 
   def run_subcommand_error(message)
-    warn("Error: #{message}")
+    Evilution::Diagnostic.warn("Error: #{message}")
     2
   end
 end

data/lib/evilution/config/validators/spec_mappings.rb

@@ -2,6 +2,7 @@
 
 require_relative "../validators"
 require_relative "base"
+require_relative "../../diagnostic"
 
 class Evilution::Config::Validators::SpecMappings < Evilution::Config::Validators::Base
   def self.call(value)
@@ -49,7 +50,7 @@ class Evilution::Config::Validators::SpecMappings < Evilution::Config::Validator
         specs.each do |spec_path|
           next if File.exist?(spec_path)
 
-          warn "[evilution] spec_mappings[#{source.inspect}]: #{spec_path} not found, skipping"
+          Evilution::Diagnostic.warn("[evilution] spec_mappings[#{source.inspect}]: #{spec_path} not found, skipping")
         end
       end
     end

data/lib/evilution/config.rb

@@ -216,8 +216,9 @@ class Evilution::Config
       #   - "call{name=debug|warn}"
 
       # Operator profile: default or strict (default: default).
-      # strict adds aggressive truthiness mutators (e.g. replaces
-      # `x.predicate?` with `nil`) intended for pre-merge audits.
+      # strict adds aggressive mutators (e.g. replaces `x.predicate?` with
+      # `nil`, or appends `rescue nil` to a raising call) intended for
+      # pre-merge audits.
       # profile: default
     YAML
   end

data/lib/evilution/equivalent/detector.rb

@@ -7,6 +7,7 @@ require_relative "heuristic/dead_code"
 require_relative "heuristic/arithmetic_identity"
 require_relative "heuristic/comment_marking"
 require_relative "heuristic/void_context"
+require_relative "heuristic/guarded_index_fetch"
 
 require_relative "../equivalent"
 
@@ -40,7 +41,8 @@ class Evilution::Equivalent::Detector
       Evilution::Equivalent::Heuristic::DeadCode.new,
       Evilution::Equivalent::Heuristic::ArithmeticIdentity.new,
       Evilution::Equivalent::Heuristic::CommentMarking.new,
-      Evilution::Equivalent::Heuristic::VoidContext.new
+      Evilution::Equivalent::Heuristic::VoidContext.new,
+      Evilution::Equivalent::Heuristic::GuardedIndexFetch.new
     ]
   end
 end

data/lib/evilution/equivalent/heuristic/guarded_index_fetch/condition.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../guarded_index_fetch"
+
+# Whether a condition, when truthy, says the read's key is there.
+#
+# That is the read itself, `recv[key].present?`, `recv.dig(key)`, or a key
+# predicate on the same receiver and key -- alone or as one side of an `&&`,
+# since both sides hold when the whole does. `refutes?` answers the mirror
+# question, for conditions that are truthy when the key is missing.
+class Evilution::Equivalent::Heuristic::GuardedIndexFetch::Condition
+  KEY_PREDICATES = %i[key? has_key? include? member?].freeze
+  SINGLE_KEY_LOOKUPS = (KEY_PREDICATES + [:dig]).freeze
+  ABSENCE_TESTS = %i[nil? blank?].freeze
+
+  def initialize(read)
+    @read = read
+  end
+
+  def proves?(node)
+    case node
+    when Prism::ParenthesesNode then parenthesized?(node)
+    when Prism::AndNode then proves?(node.left) || proves?(node.right)
+    when Prism::CallNode then read_present?(node)
+    else false
+    end
+  end
+
+  # Whether a condition, when falsy, says the read's key is there: the
+  # negation of something that proves it, `recv[key].nil?` / `.blank?`, or
+  # either as one side of an `||`, since both sides are falsy when the whole
+  # is. This is what an early exit tests: `return if config[:k].nil?`.
+  def refutes?(node)
+    case node
+    when Prism::ParenthesesNode then single_statement(node) { |inner| refutes?(inner) }
+    when Prism::OrNode then refutes?(node.left) || refutes?(node.right)
+    when Prism::CallNode then read_absent?(node)
+    else false
+    end
+  end
+
+  private
+
+  def parenthesized?(node)
+    single_statement(node) { |inner| proves?(inner) }
+  end
+
+  def single_statement(node)
+    body = node.body
+    body.is_a?(Prism::StatementsNode) && body.body.length == 1 && yield(body.body.first)
+  end
+
+  # `!cond` and `not cond` are both a call to `!`.
+  def read_absent?(call)
+    return proves?(call.receiver) if call.name == :!
+
+    ABSENCE_TESTS.include?(call.name) && @read.same?(call.receiver)
+  end
+
+  def read_present?(call)
+    return true if @read.same?(call)
+    return @read.same?(call.receiver) if call.name == :present? && call.arguments.nil?
+
+    SINGLE_KEY_LOOKUPS.include?(call.name) && @read.on_receiver?(call) && @read.keyed?(call)
+  end
+end

data/lib/evilution/equivalent/heuristic/guarded_index_fetch/disturbance.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../guarded_index_fetch"
+
+# Whether a guarded branch does anything that could take the key away again
+# after the guard saw it: assigns the variable the receiver hangs off, or
+# calls something on the receiver that changes it.
+#
+# The whole branch is searched, not just what precedes the read; inside a loop
+# "before" and "after" trade places.
+class Evilution::Equivalent::Heuristic::GuardedIndexFetch::Disturbance
+  LOCAL_WRITES = [
+    Prism::LocalVariableWriteNode, Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableOrWriteNode,
+    Prism::LocalVariableAndWriteNode, Prism::LocalVariableTargetNode
+  ].freeze
+  INSTANCE_VARIABLE_WRITES = [
+    Prism::InstanceVariableWriteNode, Prism::InstanceVariableOperatorWriteNode,
+    Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableTargetNode
+  ].freeze
+  MUTATORS = %i[[]= delete clear replace store update shift pop delete_if keep_if].freeze
+
+  def initialize(read)
+    @read = read
+  end
+
+  def in?(node)
+    disturbs?(node) || node.compact_child_nodes.any? { |child| in?(child) }
+  end
+
+  private
+
+  def disturbs?(node)
+    reassigns_root?(node) || mutates_receiver?(node)
+  end
+
+  def reassigns_root?(node)
+    writes = if @read.local_root?
+               LOCAL_WRITES
+             elsif @read.instance_variable_root?
+               INSTANCE_VARIABLE_WRITES
+             else
+               []
+             end
+    writes.any? { |type| node.is_a?(type) } && node.name == @read.root_name
+  end
+
+  def mutates_receiver?(node)
+    node.is_a?(Prism::CallNode) && @read.on_receiver?(node) && mutator?(node.name)
+  end
+
+  def mutator?(name)
+    MUTATORS.include?(name) || name.end_with?("!")
+  end
+end

data/lib/evilution/equivalent/heuristic/guarded_index_fetch/early_exit.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "../guarded_index_fetch"
+
+# A guard that leaves when the key is missing protects what comes after it in
+# the same statement list:
+#
+#   return unless config[:k]
+#   style << config[:k]          # fetch cannot raise here
+#
+# The guard is an `unless` whose condition says the key is there, an `if`
+# whose condition says it is not, or `cond or return` -- with a body ending in
+# `return`, `next`, `break`, `raise` or `fail`, and no else branch to fall
+# through. `next` and `break` leave only the current iteration, which is all
+# the statements after them in the block's body belong to.
+#
+# Nothing between the guard and the read, nor the statement holding the read,
+# may change the receiver; that statement is checked whole, since a loop in it
+# runs its end before its start the second time round.
+class Evilution::Equivalent::Heuristic::GuardedIndexFetch::EarlyExit
+  EXIT_NODES = [Prism::ReturnNode, Prism::NextNode, Prism::BreakNode].freeze
+  EXIT_CALLS = %i[raise fail].freeze
+
+  def initialize(statements, read)
+    @statements = statements
+    @read = read
+    @condition = Evilution::Equivalent::Heuristic::GuardedIndexFetch::Condition.new(read)
+  end
+
+  # child: the statement of this list that holds the read.
+  def protects?(child)
+    return false unless @statements.is_a?(Prism::StatementsNode)
+
+    list = @statements.body
+    position = list.index { |statement| statement.equal?(child) }
+    guard = position && nearest_guard(list, position)
+    return false unless guard
+
+    list[(guard + 1)..position].none? { |statement| disturbance.in?(statement) }
+  end
+
+  private
+
+  # The last guard before the read: an earlier one would have more statements
+  # after it to answer for, not fewer.
+  def nearest_guard(list, position)
+    (0...position).reverse_each.find { |index| guard?(list[index]) }
+  end
+
+  def guard?(statement)
+    case statement
+    when Prism::UnlessNode then leaves?(statement, statement.else_clause) && @condition.proves?(statement.predicate)
+    when Prism::IfNode then leaves?(statement, statement.subsequent) && @condition.refutes?(statement.predicate)
+    when Prism::OrNode then exit?(statement.right) && @condition.proves?(statement.left)
+    else false
+    end
+  end
+
+  def leaves?(conditional, other_branch)
+    body = conditional.statements
+    other_branch.nil? && body.is_a?(Prism::StatementsNode) && exit?(body.body.last)
+  end
+
+  def exit?(node)
+    return true if EXIT_NODES.any? { |type| node.is_a?(type) }
+
+    node.is_a?(Prism::CallNode) && node.receiver.nil? && EXIT_CALLS.include?(node.name)
+  end
+
+  def disturbance
+    @disturbance ||= Evilution::Equivalent::Heuristic::GuardedIndexFetch::Disturbance.new(@read)
+  end
+end

data/lib/evilution/equivalent/heuristic/guarded_index_fetch/guard.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../guarded_index_fetch"
+
+# One node that may guard a read: an `if` (ternary and modifier forms
+# included), an `unless` with an else, or an `&&`. It protects the part that
+# runs only when its condition held -- provided the condition says the key is
+# there and that part leaves the receiver alone.
+class Evilution::Equivalent::Heuristic::GuardedIndexFetch::Guard
+  def initialize(node, read)
+    @node = node
+    @read = read
+  end
+
+  def protects?(child)
+    guarded = guarded_part
+    return false unless guarded && guarded.equal?(child)
+
+    Evilution::Equivalent::Heuristic::GuardedIndexFetch::Condition.new(@read).proves?(condition) &&
+      !Evilution::Equivalent::Heuristic::GuardedIndexFetch::Disturbance.new(@read).in?(guarded)
+  end
+
+  private
+
+  def guarded_part
+    case @node
+    when Prism::IfNode then @node.statements
+    when Prism::UnlessNode then @node.else_clause
+    when Prism::AndNode then @node.right
+    end
+  end
+
+  def condition
+    @node.is_a?(Prism::AndNode) ? @node.left : @node.predicate
+  end
+end

data/lib/evilution/equivalent/heuristic/guarded_index_fetch/index_read.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../guarded_index_fetch"
+
+# One `recv[key]` read, reduced to what makes another read "the same": the
+# receiver's source and a literal key.
+#
+# The receiver has to be something that can be named twice and mean the same
+# thing both times: a variable, a constant, or calls without arguments or
+# block on one of those. `lookup(id)[:k]` is not.
+class Evilution::Equivalent::Heuristic::GuardedIndexFetch::IndexRead
+  KEY_TYPES = [Prism::SymbolNode, Prism::StringNode, Prism::IntegerNode].freeze
+  NAMED_TYPES = [
+    Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode,
+    Prism::GlobalVariableReadNode, Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::SelfNode
+  ].freeze
+
+  attr_reader :receiver_source, :key_source, :root
+
+  def self.from(node)
+    key = single_argument(node)
+    return nil unless key && literal?(key) && node.receiver && stable?(node.receiver)
+
+    new(receiver_source: node.receiver.slice, key_source: key.slice, root: root_of(node.receiver))
+  end
+
+  def self.single_argument(node)
+    return nil unless node.arguments && node.arguments.arguments.length == 1
+
+    node.arguments.arguments.first
+  end
+
+  def self.literal?(node)
+    KEY_TYPES.any? { |type| node.is_a?(type) }
+  end
+
+  def self.stable?(node)
+    return true if NAMED_TYPES.any? { |type| node.is_a?(type) }
+    return false unless node.is_a?(Prism::CallNode) && node.arguments.nil? && node.block.nil?
+
+    node.receiver.nil? || stable?(node.receiver)
+  end
+
+  # The variable a receiver hangs off: `user` in `user.settings`.
+  def self.root_of(node)
+    node = node.receiver while node.is_a?(Prism::CallNode) && node.receiver
+    node
+  end
+
+  def initialize(receiver_source:, key_source:, root:)
+    @receiver_source = receiver_source
+    @key_source = key_source
+    @root = root
+  end
+
+  def root_name
+    root.respond_to?(:name) ? root.name : nil
+  end
+
+  def local_root?
+    root.is_a?(Prism::LocalVariableReadNode)
+  end
+
+  def instance_variable_root?
+    root.is_a?(Prism::InstanceVariableReadNode)
+  end
+
+  # Whether a node is this read again: `recv[key]`.
+  def same?(node)
+    node.is_a?(Prism::CallNode) && node.name == :[] && on_receiver?(node) && keyed?(node)
+  end
+
+  def on_receiver?(call)
+    !call.receiver.nil? && call.receiver.slice == receiver_source
+  end
+
+  # Whether a call's only argument is this read's key.
+  def keyed?(call)
+    key = self.class.single_argument(call)
+    !key.nil? && key.slice == key_source
+  end
+end

data/lib/evilution/equivalent/heuristic/guarded_index_fetch/node_path.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../guarded_index_fetch"
+
+# The nodes from the subject down to the `recv[key]` call a mutation rewrote,
+# outermost first; nil when it cannot be found.
+#
+# Line and column are not enough: in `a[:x][:y]` the outer and the inner read
+# start at the same place. The mutated source settles it -- the rewritten read
+# is the one whose receiver is now followed by `.fetch(`.
+class Evilution::Equivalent::Heuristic::GuardedIndexFetch::NodePath
+  FETCH_CALL = ".fetch("
+
+  def call(mutation)
+    root = mutation.subject.node
+    mutated_source = mutation.mutated_source
+    return nil unless root && mutated_source
+
+    search(root, mutation, mutated_source, [])
+  end
+
+  private
+
+  def search(node, mutation, mutated_source, ancestors)
+    path = ancestors + [node]
+    return path if rewritten?(node, mutation, mutated_source)
+
+    node.compact_child_nodes.each do |child|
+      found = search(child, mutation, mutated_source, path)
+      return found if found
+    end
+    nil
+  end
+
+  def rewritten?(node, mutation, mutated_source)
+    return false unless node.is_a?(Prism::CallNode) && node.name == :[] && node.receiver
+
+    location = node.location
+    return false unless location.start_line == mutation.line && location.start_column == mutation.column
+
+    mutated_source.byteslice(node.receiver.location.end_offset, FETCH_CALL.bytesize) == FETCH_CALL
+  end
+end