saboteur 0.7.0 → 0.8.0

data/lib/saboteur/mutation_source/method_swap.rb

@@ -16,9 +16,29 @@ module Saboteur
 
       SWAPS = { min: "max", max: "min", any?: "all?", all?: "any?", map: "each", each: "map" }.freeze
 
+      # Node types that mix used and discarded child positions get a named
+      # handler; anything not listed here is conservative: every child's
+      # value is treated as used (#440).
+      CONTAINER_HANDLERS = {
+        Prism::StatementsNode => :visit_statements,
+        Prism::IfNode => :visit_if,
+        Prism::UnlessNode => :visit_unless,
+        Prism::ElseNode => :visit_else,
+        Prism::EnsureNode => :visit_ensure,
+        Prism::CaseNode => :visit_case,
+        Prism::CaseMatchNode => :visit_case,
+        Prism::WhenNode => :visit_when,
+        Prism::InNode => :visit_in,
+        Prism::BeginNode => :visit_begin,
+        Prism::RescueNode => :visit_rescue,
+        Prism::WhileNode => :visit_loop,
+        Prism::UntilNode => :visit_loop
+      }.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) }
+        @discard_depth = 0
       end
 
       def name
@@ -27,6 +47,133 @@ module Saboteur
 
       private
 
+      # Overrides OperatorVisit#visit to track positions whose value is
+      # syntactically discarded: a non-last statement, and - recursing from a
+      # discarded statement - the tail expression of each branch of an
+      # if/elsif/else/unless/case/when, a begin/rescue body, or a
+      # while/until body (a loop's value never observes its body), or an
+      # ensure body (its value never contributes to the result). each
+      # and map differ only in their return value (both run the block the
+      # same way), so swapping them in a discarded-value position yields
+      # an equivalent mutant (#399, #440). A call whose value flows into
+      # a predicate, receiver, block result, or control-flow argument
+      # (return/break/next) is used and stays swappable, as is the whole
+      # body of a def or block. A lazy receiver breaks the equivalence:
+      # lazy.map defers the block, so discarding it runs nothing (#431).
+      # Only a `.lazy` in the receiver chain is detected; a Lazy held in a
+      # variable, parameter or ivar is not, and its swaps are suppressed.
+      def visit(node, subject, found)
+        return if node.nil? || OperatorVisit::SCOPE_NODES.any? { |scope| node.is_a?(scope) }
+
+        handler = CONTAINER_HANDLERS[node.class]
+        handler ? send(handler, node, subject, found) : visit_used_children(node, subject, found)
+      end
+
+      # Non-last statements are discarded-value positions; the last
+      # statement inherits the surrounding context (#399).
+      def visit_statements(node, subject, found)
+        node.body.each_with_index do |statement, index|
+          next if arid?(statement)
+
+          if index < node.body.size - 1
+            discarded { visit(statement, subject, found) }
+          else
+            visit(statement, subject, found)
+          end
+        end
+      end
+
+      def visit_else(node, subject, found)
+        visit(node.statements, subject, found)
+      end
+
+      # An ensure body's value never contributes to the result, so it is
+      # always a discarded-value position (#440).
+      def visit_ensure(node, subject, found)
+        discarded { visit(node.statements, subject, found) }
+      end
+
+      def visit_in(node, subject, found)
+        used { visit(node.pattern, subject, found) }
+        visit(node.statements, subject, found)
+      end
+
+      def visit_if(node, subject, found)
+        visit_branch(node, subject, found, :subsequent)
+      end
+
+      def visit_unless(node, subject, found)
+        visit_branch(node, subject, found, :else_clause)
+      end
+
+      # Branch bodies inherit the discard context; the predicate's value
+      # selects the branch, so it is always used (#440).
+      def visit_branch(node, subject, found, else_reader)
+        used { visit(node.predicate, subject, found) }
+        visit(node.statements, subject, found)
+        visit(node.public_send(else_reader), subject, found)
+      end
+
+      def visit_case(node, subject, found)
+        used { visit(node.predicate, subject, found) }
+        node.conditions.each { |condition| visit(condition, subject, found) }
+        visit(node.else_clause, subject, found)
+      end
+
+      def visit_when(node, subject, found)
+        node.conditions.each { |condition| used { visit(condition, subject, found) } }
+        visit(node.statements, subject, found)
+      end
+
+      def visit_begin(node, subject, found)
+        visit(node.statements, subject, found)
+        visit(node.rescue_clause, subject, found)
+        visit(node.else_clause, subject, found)
+        discarded { visit(node.ensure_clause, subject, found) }
+      end
+
+      def visit_rescue(node, subject, found)
+        node.exceptions.each { |exception| used { visit(exception, subject, found) } }
+        visit(node.statements, subject, found)
+        visit(node.subsequent, subject, found)
+      end
+
+      # A loop's value never observes its body, so the body is always a
+      # discarded-value position (#440).
+      def visit_loop(node, subject, found)
+        used { visit(node.predicate, subject, found) }
+        discarded { visit(node.statements, subject, found) }
+      end
+
+      # Default: every child's value is consumed by its parent.
+      def visit_used_children(node, subject, found)
+        mutate_node(node, subject, found)
+        node.compact_child_nodes.each { |child| used { visit(child, subject, found) } }
+      end
+
+      # Marks value-discarded positions during the walk. `used` resets the
+      # depth where a child's value is consumed by its parent.
+      def discarded
+        @discard_depth += 1
+        yield
+      ensure
+        @discard_depth -= 1
+      end
+
+      def used
+        depth = @discard_depth
+        @discard_depth = 0
+        yield
+      ensure
+        @discard_depth = depth
+      end
+
+      # Any `.lazy` in the receiver chain, syntactically.
+      def lazy_receiver?(node)
+        node = node.receiver while node.is_a?(Prism::CallNode) && node.name != :lazy
+        node.is_a?(Prism::CallNode)
+      end
+
       def mutate_node(node, subject, found)
         swap(node, subject, found) if node.is_a?(Prism::CallNode)
       end
@@ -34,6 +181,7 @@ module Saboteur
       def swap(node, subject, found)
         replacement = SWAPS[node.name]
         return unless replacement && node.receiver
+        return if @discard_depth.positive? && %w[each map].include?(node.name.to_s) && !lazy_receiver?(node.receiver)
 
         location = node.message_loc
         edit = Edit.new(file: subject.file, start_byte: location.start_offset,

data/lib/saboteur/mutation_source/operator_assignment.rb

@@ -24,7 +24,7 @@ module Saboteur
 
       def mutations_for(subject)
         found = []
-        visit(subject.node.body, subject, found)
+        visit(subject.body_node, subject, found)
         found
       end
 

data/lib/saboteur/mutation_source/operator_examples.rb

@@ -24,6 +24,7 @@ module Saboteur
         "literal_boolean" => "true -> false",
         "argument_removal" => "send(a, b) -> send(a)",
         "pair_removal" => "{a: 1, b: 2} -> {b: 2}",
+        "element_removal" => "TAGS = [a, b] -> TAGS = [b]",
         "endpoint_replacement" => "xs.first -> xs.last",
         "chain_removal" => "x.first.to_s -> x.to_s",
         "range" => "1..3 -> 1...3",
@@ -31,7 +32,8 @@ module Saboteur
         "condition_negation" => "x ? a : b -> !(x) ? a : b",
         "method_swap" => "xs.min -> xs.max",
         "operand_replacement" => "a + b -> a",
-        "interpolation_removal" => "\"hi \#{name}\" -> \"hi \""
+        "interpolation_removal" => "\"hi \#{name}\" -> \"hi \"",
+        "regex_replacement" => "/\\A\\d+\\z/ -> /\\d+\\z/"
       }.freeze
     end
   end

data/lib/saboteur/mutation_source/operator_registry.rb

@@ -31,13 +31,15 @@ module Saboteur
         "literal_boolean" => "Swap a boolean literal",
         "argument_removal" => "Remove a call argument",
         "pair_removal" => "Remove a hash pair",
+        "element_removal" => "Remove an element of a constant array literal",
         "endpoint_replacement" => "Swap explicit no-argument first and last",
         "chain_removal" => "Remove one call from a method chain",
         "method_swap" => "Swap a method with its semantic opposite",
         "operand_replacement" => "Replace a binary operation with one operand",
-        "interpolation_removal" => "Remove part of an interpolated string"
+        "interpolation_removal" => "Remove part of an interpolated string",
+        "regex_replacement" => "Drop a regex anchor or swap a regex quantifier"
       }.freeze
-      POLICY_VERSION = 2
+      POLICY_VERSION = 3
       TIERS = { "all" => DESCRIPTIONS.keys.freeze }.freeze
 
       def self.list(out, names: [], excluded: [])

data/lib/saboteur/mutation_source/operator_visit.rb

@@ -13,7 +13,7 @@ module Saboteur
 
       def mutations_for(subject)
         found = []
-        visit(subject.node.body, subject, found)
+        visit(subject.body_node, subject, found)
         found
       end
 

data/lib/saboteur/mutation_source/pair_removal.rb

@@ -3,11 +3,14 @@
 
 require "prism"
 require_relative "base"
+require_relative "entry_edits"
 
 module Saboteur
   module MutationSource
     # Deletes one association from a hash literal or keyword argument list.
     class PairRemoval < Base
+      include EntryEdits
+
       BOUNDARIES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode,
                     Prism::ParametersNode, Prism::BlockParametersNode].freeze
 
@@ -19,10 +22,12 @@ module Saboteur
         "pair_removal"
       end
 
-      def mutations_for(subject)
+      # root: the node to walk instead of the subject's method body (a
+      # constant's literal, see MutationSource::ConstantLiterals).
+      def mutations_for(subject, root: nil)
         found = []
         tokens = Prism.lex(subject.file_source).value.map(&:first)
-        visit(subject.node.body, subject, found, tokens)
+        visit(root || subject.body_node, subject, found, tokens)
         found
       end
 
@@ -56,24 +61,16 @@ module Saboteur
           next unless pair.is_a?(Prism::AssocNode)
           next if heredoc?(pair)
 
-          edits = [delete(subject, pair.location)]
-          separator = separator_for(node, pairs, index, tokens, call)
-          edits << delete(subject, separator) if separator
+          edits = [delete_entry(subject, pair.location)]
+          # Removing the first keyword argument may need the comma after the
+          # call's last positional argument.
+          before = call.arguments.arguments[0...-1].last if call
+          separator = entry_separator(pairs, index, ending_for(node, call), tokens, before: before)
+          edits << delete_entry(subject, separator) if separator
           found << Mutation.new(subject_id: subject.id, operator: name, edits: edits, source: name)
         end
       end
 
-      def separator_for(node, pairs, index, tokens, call)
-        pair = pairs[index]
-        ending = ending_for(node, call)
-        after = comma_between(pair.location.end_offset, ending, tokens)
-        return after if after
-
-        previous = pairs[0...index].last
-        previous ||= call.arguments.arguments[0...-1].last if call
-        comma_between(previous.location.end_offset, pair.location.start_offset, tokens) if previous
-      end
-
       def ending_for(node, call)
         return node.closing_loc.start_offset if node.is_a?(Prism::HashNode)
         return call.closing_loc.start_offset if call.closing_loc
@@ -81,21 +78,6 @@ module Saboteur
 
         node.location.end_offset
       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/range_replacement.rb

@@ -19,7 +19,7 @@ module Saboteur
 
       def mutations_for(subject)
         found = []
-        visit(subject.node.body, subject, found)
+        visit(subject.body_node, subject, found)
         found
       end
 

data/lib/saboteur/mutation_source/regex_replacement.rb

@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+require_relative "operator_visit"
+
+module Saboteur
+  module MutationSource
+    # Weakens a regex literal: drops one anchor (\A, \z, \Z, ^, $) at a time
+    # and swaps each + or * quantifier for the other (#135). Escaped
+    # characters, character classes, and lazy or possessive stacks stay
+    # untouched, and interpolated regexes stay out: their bytes are not a
+    # stable 1:1 map. Anchors make validations decisive, so a dropped anchor
+    # or a widened quantifier is exactly the mutant a weak test misses.
+    class RegexReplacement < Base
+      include OperatorVisit
+
+      # 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
+        "regex_replacement"
+      end
+
+      BACKSLASH = 0x5C
+      ANCHOR_ESCAPES = %w[\\A \\z \\Z].freeze
+
+      private
+
+      def mutate_node(node, subject, found)
+        return unless node.is_a?(Prism::RegularExpressionNode)
+
+        base = node.content_loc.start_offset
+        scan_anchors_and_quantifiers(node.content) do |offset, length, replacement|
+          edit = Edit.new(file: subject.file, start_byte: base + offset, end_byte: base + offset + length,
+                          replacement: replacement)
+          found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+        end
+      end
+
+      # Yields [offset, length, replacement] for each anchor drop and
+      # quantifier swap, scanning bytes so offsets line up with the file.
+      def scan_anchors_and_quantifiers(pattern)
+        bytes = pattern.bytes
+        depth = 0
+        index = 0
+        while index < bytes.size
+          if bytes[index] == BACKSLASH
+            yield index, 2, "" if depth.zero? && ANCHOR_ESCAPES.include?(pattern.byteslice(index, 2))
+            index += 2
+          else
+            depth = scan_plain_byte(bytes, index, depth) { |offset, replacement| yield offset, 1, replacement }
+            index += 1
+          end
+        end
+      end
+
+      # One non-escape byte; returns the character-class depth after it.
+      def scan_plain_byte(bytes, index, depth)
+        case bytes[index]
+        # [ opens a class only at top level or as a POSIX [:class:];
+        # inside a class it is a literal member.
+        when 0x5B then depth.zero? || bytes[index + 1] == 0x3A ? depth + 1 : depth
+        when 0x5D then depth.positive? ? depth - 1 : 0 # ]
+        when 0x5E, 0x24 # ^ $
+          yield index, "" if depth.zero?
+          depth
+        when 0x2B, 0x2A # + *
+          yield index, (bytes[index] == 0x2B ? "*" : "+") if depth.zero? && plain_quantifier?(bytes, index)
+          depth
+        else
+          depth
+        end
+      end
+
+      # A bare quantifier: not the start of the pattern, not after an open
+      # group or alternation, and not stacked into a lazy (+?, ??) or
+      # possessive (*+, ++) form on either side.
+      def plain_quantifier?(bytes, index)
+        return false if index.zero?
+
+        previous = bytes[index - 1]
+        return false if [0x28, 0x7C, 0x3F, 0x2B, 0x2A].include?(previous) # ( | ? + *
+
+        nxt = bytes[index + 1]
+        nxt != 0x2B && nxt != 0x2A && nxt != 0x3F # + * ?
+      end
+    end
+  end
+end

data/lib/saboteur/preview.rb

@@ -1,30 +1,40 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require "json"
 require_relative "engine"
 require_relative "text"
+require_relative "version"
 
 module Saboteur
   # Source-only planning. Never boots the host or executes its test suite.
   class Preview
-    def initialize(config, out:, err:)
+    # Version of the --format json inventory (#469). Consumers ignore fields
+    # they do not know; only a breaking change raises this number.
+    SCHEMA_VERSION = 1
+
+    def initialize(config, out:, err:, format: "text")
       @config = config
       @out = out
       @diagnostics = Engine::Diagnostics.new(err)
+      @json = format == "json"
+      @inventory = []
+      @skipped = []
     end
 
     def call
       announce_operators
       selection = Engine::SubjectSelection.new(@config, @diagnostics)
       subjects = selection.select(@config.included_files)
-      scope = selection.changed_lines && Engine::DiffScope.new(selection.changed_lines)
+      scope = selection.behavior_lines && Engine::DiffScope.new(selection.behavior_lines)
       guard = MutationSource::HazardGuard.new(@config["hazard"]) unless @config["allow_hazardous"]
       candidates = Engine::Candidates.new(Engine::Candidates.build_sources(@config), @diagnostics, hazard_guard: guard)
-      lists = subjects.map { |subject| planned(subject, candidates, scope) }
+      lists = shard_lists(subjects, subjects.map { |subject| planned(subject, candidates, scope) })
       inline_suppressions
       incomplete = @diagnostics.discovery_failures.size
-      @out.puts("Total: #{lists.sum(&:size)} mutants; #{@diagnostics.omissions.sum(&:count)} " \
-                "dropped by max_mutants_per_method#{incomplete_note(incomplete)}")
+      return print_inventory(subjects, lists, incomplete) if @json
+
+      print_totals(lists, incomplete)
       incomplete.zero? ? estimate(subjects, lists) : @out.puts("no estimate: source discovery was incomplete")
       print_warnings
       nil
@@ -32,25 +42,37 @@ module Saboteur
 
     private
 
+    def shard_lists(subjects, lists)
+      return lists unless @config["shard"]
+
+      @shard = Engine::Shard.parse(@config["shard"])
+      @shard.select(subjects, lists)
+    end
+
+    def print_totals(lists, incomplete)
+      @out.puts(@shard.line) if @shard
+      @out.puts("Total: #{lists.sum(&:size)} mutants; #{@diagnostics.omissions.sum(&:count)} " \
+                "dropped by max_mutants_per_method#{incomplete_note(incomplete)}")
+    end
+
     def print_warnings
       @diagnostics.warnings.each { |warning| @out.puts("warning: #{warning}") }
     end
 
     def announce_operators
-      @out.puts("Operators: #{@config.operator_policy['effective'].join(', ')}")
+      @out.puts("Operators: #{@config.operator_policy['effective'].join(', ')}") unless @json
     end
 
     # Candidate filtering precedes diff restriction and the per-method cap.
     # Name that scope rather than implying these rows were executed or scored.
     def inline_suppressions
       entries = @diagnostics.inline_suppressions
-      return if entries.empty?
+      return if entries.empty? || @json
 
       @out.puts("Inline suppressions: #{entries.size} candidates in selected methods " \
                 "(before diff restriction and per-method cap; outside the planned total)")
       entries.each do |entry|
-        path = entry[:file].delete_prefix("#{@config.root}/")
-        @out.puts("  #{path}:#{entry[:line]} #{entry[:subject]} #{entry[:operator]} " \
+        @out.puts("  #{relative_path(entry[:file])}:#{entry[:line]} #{entry[:subject]} #{entry[:operator]} " \
                   "#{entry[:digest]}: #{entry[:reason]}")
       end
     end
@@ -106,11 +128,97 @@ module Saboteur
       list = candidates.for(subject)
       list = scope.restrict(subject, list) if scope
       limit = @config["max_mutants_per_method"]
-      @diagnostics.record_omission(subject, count: list.size - limit, limit: limit) if list.size > limit
+      if list.size > limit
+        @diagnostics.record_omission(subject, count: list.size - limit, limit: limit)
+        list.drop(limit).each { |(mutation, _)| record_skip(subject, mutation, "max_mutants_per_method") } if @json
+      end
       list = list.first(limit)
-      path = subject.file.delete_prefix("#{@config.root}/")
-      @out.puts("#{path}:#{subject.start_line} #{subject.id}  #{list.size} mutants")
+      if @json
+        list.each { |(mutation, _)| @inventory << mutant_entry(subject, mutation) }
+      else
+        @out.puts("#{relative_path(subject.file)}:#{subject.start_line} #{subject.id}  #{list.size} mutants")
+      end
       list
     end
+
+    # The machine-readable inventory (#469): every planned mutant named by
+    # the stable digest a run or --id replay computes, plus the candidates
+    # that were planned but not runnable, each with its skip reason.
+    def print_inventory(subjects, lists, incomplete)
+      @out.puts(JSON.pretty_generate(
+                  schema_version: SCHEMA_VERSION,
+                  saboteur_version: VERSION,
+                  mode: "dry-run",
+                  operators: @config.operator_policy["effective"],
+                  test_selection: @config["test_selection"],
+                  tests: @config["tests"],
+                  subjects: subjects.zip(lists).map { |subject, list| subject_entry(subject, list) },
+                  mutants: @inventory,
+                  skipped: @skipped + suppression_entries,
+                  totals: {
+                    mutants: lists.sum(&:size),
+                    dropped_by_max_mutants_per_method: @diagnostics.omissions.sum(&:count),
+                    incomplete_files: incomplete
+                  },
+                  estimated_seconds: incomplete.zero? ? estimated_seconds(subjects, lists) : nil,
+                  warnings: @diagnostics.warnings
+                ))
+      nil
+    end
+
+    def estimated_seconds(subjects, lists)
+      map = cached_map
+      seconds = map && work_seconds(map, subjects, lists)
+      seconds&.round(2)
+    end
+
+    def subject_entry(subject, list)
+      { id: subject.id, file: relative_path(subject.file), start_line: subject.start_line,
+        end_line: subject.end_line, mutants: list.size }
+    end
+
+    # Byte offsets index the file as read from disk, like the Stryker
+    # report; original and replacement text make each edit self-contained.
+    def mutant_entry(subject, mutation)
+      {
+        digest: mutation.digest(subject_start: subject.start_byte, original_source: subject.file_source),
+        subject: subject.id,
+        operator: mutation.operator.to_s,
+        file: relative_path(subject.file),
+        line: subject.line_of(mutation.edits.first.start_byte),
+        edits: mutation.edits.map do |edit|
+          { start_byte: edit.start_byte, end_byte: edit.end_byte,
+            original: source_span(subject, edit), replacement: edit.replacement }
+        end
+      }
+    end
+
+    def record_skip(subject, mutation, reason)
+      @skipped << mutant_entry(subject, mutation).merge(reason: reason)
+    end
+
+    # Inline-suppressed and hazard-refused candidates with their reasons,
+    # recorded during candidate filtering, before diff restriction and the
+    # per-method cap (the same scope the text audit names).
+    def suppression_entries
+      inline = @diagnostics.inline_suppressions.map do |entry|
+        { digest: entry[:digest], subject: entry[:subject], operator: entry[:operator].to_s,
+          file: relative_path(entry[:file]), line: entry[:line], reason: "inline_suppression: #{entry[:reason]}" }
+      end
+      hazards = @diagnostics.generation_events.select { |event| event.source == "hazard_guard" }.map do |event|
+        { subject: event.subject, operator: event.operator.to_s, file: relative_path(event.file),
+          reason: "hazardous" }
+      end
+      inline + hazards
+    end
+
+    def relative_path(file)
+      file.delete_prefix("#{@config.root}/")
+    end
+
+    def source_span(subject, edit)
+      subject.file_source.byteslice(edit.start_byte, edit.end_byte - edit.start_byte).to_s
+             .force_encoding(Encoding::UTF_8)
+    end
   end
 end

data/lib/saboteur/refinement_activations.rb

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  # The lexical `using` sites of one parsed file (#634). A bare `using`
+  # activates its refinement from where it sits to the end of its own
+  # scope: a class or module body, or the whole file at the top level.
+  # Activation is lexical, not namespaced: a `class ::Q` nested inside
+  # the body still sees it, while a reopened body with the same constant
+  # path after the scope's `end` does not. Sites therefore compare byte
+  # ranges, not constant paths: a site covers a subject that starts after
+  # the `using` and before the scope's closing `end`. A `using` inside a
+  # method or block body cannot be scoped this way, so one anywhere keeps
+  # the old whole-file skip. Skipping only ever means "not mutated",
+  # never a wrong verdict.
+  class RefinementActivations
+    Site = Data.define(:start_byte, :scope_end, :dynamic_scope) do
+      def covers?(subject)
+        !dynamic_scope && subject.start_byte > start_byte && subject.start_byte < scope_end
+      end
+    end
+
+    def self.mark(subjects, program)
+      sites = []
+      collect(program, program.end_offset, false, sites)
+      return if sites.empty?
+
+      if sites.any?(&:dynamic_scope)
+        subjects.each { |subject| subject.skip_reason = "refinements" }
+        return
+      end
+
+      subjects.each do |subject|
+        subject.skip_reason = "refinements" if sites.any? { |site| site.covers?(subject) }
+      end
+    end
+
+    def self.collect(node, scope_end, dynamic, sites)
+      if node.is_a?(Prism::CallNode) && node.name == :using && node.receiver.nil?
+        sites << Site.new(start_byte: node.location.start_offset, scope_end: scope_end, dynamic_scope: dynamic)
+      end
+
+      descend(node, scope_end, dynamic, sites)
+    end
+
+    def self.descend(node, scope_end, dynamic, sites)
+      case node
+      when Prism::ClassNode
+        collect(node.superclass, scope_end, dynamic, sites) if node.superclass
+        collect(node.body, node.end_offset, dynamic, sites) if node.body
+      when Prism::ModuleNode, Prism::SingletonClassNode
+        collect(node.body, node.end_offset, dynamic, sites) if node.body
+      when Prism::DefNode, Prism::BlockNode, Prism::LambdaNode
+        node.compact_child_nodes.each { |child| collect(child, scope_end, true, sites) }
+      else
+        node.compact_child_nodes.each { |child| collect(child, scope_end, dynamic, sites) }
+      end
+    end
+  end
+end