evilution 1.3.0 → 1.4.0

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../heuristic"
+
+# `index_to_fetch` turns `recv[key]` into `recv.fetch(key)`, which differs only
+# when the key is absent. Under a guard that is truthy only when the key is
+# there -- `if config[:k]`, `config.key?(:k) && ...` -- it cannot be absent, so
+# the mutant behaves like the original and no test can kill it.
+#
+# The read in the guard itself is a different matter: `if config.fetch(:k)`
+# raises where `if config[:k]` took the other branch. Only reads inside the
+# guarded part match -- the branch a guard opens, or the statements after a
+# guard that leaves (`return unless config[:k]`).
+#
+# A heuristic, not a proof: a hash with a default value passes the guard with
+# the key absent, and a method-call receiver may answer with another object
+# the second time.
+class Evilution::Equivalent::Heuristic::GuardedIndexFetch
+  OPERATOR = "index_to_fetch"
+
+  def match?(mutation)
+    return false unless mutation.operator_name == OPERATOR
+
+    path = NodePath.new.call(mutation)
+    return false unless path
+
+    read = IndexRead.from(path.last)
+    return false unless read
+
+    guarded?(path, read)
+  end
+
+  private
+
+  # Walks outwards from the read. Each step asks whether the node just left
+  # was the guarded part of its parent, or a statement that follows an early
+  # exit in its parent's list; a scope the guard does not reach into ends the
+  # walk.
+  def guarded?(path, read)
+    path.each_cons(2).reverse_each do |parent, child|
+      return false if scope_boundary?(parent, read)
+      return true if Guard.new(parent, read).protects?(child) || EarlyExit.new(parent, read).protects?(child)
+    end
+    false
+  end
+
+  # A nested method or lambda runs later, when the guard no longer speaks for
+  # the receiver. A block runs in place, unless it declares the receiver's
+  # name as its own variable.
+  def scope_boundary?(node, read)
+    case node
+    when Prism::DefNode, Prism::LambdaNode then true
+    when Prism::BlockNode then read.local_root? && node.locals.include?(read.root_name)
+    else false
+    end
+  end
+end
+
+require_relative "guarded_index_fetch/node_path"
+require_relative "guarded_index_fetch/index_read"
+require_relative "guarded_index_fetch/condition"
+require_relative "guarded_index_fetch/disturbance"
+require_relative "guarded_index_fetch/guard"
+require_relative "guarded_index_fetch/early_exit"

data/lib/evilution/example_filter.rb

@@ -3,6 +3,9 @@
 require "prism"
 require_relative "version"
 require_relative "spec_ast_cache"
+require_relative "ast/value_object_definition"
+require_relative "ast/scope_declaration"
+require_relative "ast/aasm_declaration"
 
 class Evilution::ExampleFilter
   VALID_FALLBACKS = %i[full_file unresolved].freeze
@@ -119,8 +122,50 @@ class Evilution::ExampleFilter
       @class_stack.pop
     end
 
+    # A value-object definition assigned to a constant names the type its
+    # specs build (`Point = Data.define(:x, :y)` -> `Point`), like a class.
+    def visit_constant_write_node(node)
+      within_value_object(node, node.name.to_s) { super }
+    end
+
+    def visit_constant_path_write_node(node)
+      within_value_object(node, node.target.name.to_s) { super }
+    end
+
+    # A scope declaration names the class method its specs call
+    # (`scope :for_owner, -> { }` -> `for_owner`), like a def; nothing inside
+    # its body names anything closer.
+    #
+    # An aasm event or state names the methods its specs call (`event :ship`
+    # -> `ship!`, `state :paid` -> `paid?`), which share its name as a word.
+    def visit_call_node(node)
+      return super unless target_within?(node)
+
+      token = declaration_token(node)
+      return super unless token
+
+      @token = token
+    end
+
     private
 
+    def declaration_token(node)
+      if Evilution::AST::ScopeDeclaration.body_of(node)
+        Evilution::AST::ScopeDeclaration.scope_name(node)
+      else
+        Evilution::AST::AasmDeclaration.token_at(node, @target_line)
+      end
+    end
+
+    def within_value_object(node, name)
+      return yield unless Evilution::AST::ValueObjectDefinition.match?(node.value)
+
+      @class_stack.push(name)
+      capture_if_match(node)
+      yield
+      @class_stack.pop
+    end
+
     def capture_if_match(node)
       return if @found
       return unless target_within?(node)

data/lib/evilution/hooks/registry.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../hooks"
+require_relative "../diagnostic"
 
 class Evilution::Hooks::Registry
   def initialize(on_error: nil)
@@ -54,7 +55,7 @@ class Evilution::Hooks::Registry
     if @on_error
       @on_error.call(event, error)
     else
-      warn "[evilution] hook error in #{event}: #{error.message}"
+      Evilution::Diagnostic.warn("[evilution] hook error in #{event}: #{error.message}")
     end
   end
 end

data/lib/evilution/integration/base.rb

@@ -25,6 +25,8 @@ class Evilution::Integration::Base
 
     fire_hook(:mutation_insert_post, mutation: mutation, file_path: mutation.file_path)
     run_tests(mutation)
+  ensure
+    @mutation_applier.restore(mutation)
   end
 
   private

data/lib/evilution/integration/known_failures.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+
+# The tests the baseline saw failing before any mutation ran, by the ids the
+# integration gives them.
+#
+# Such a test fails whatever the mutation is, so a mutation run in which
+# nothing else failed has no verdict. The question is asked in the process
+# that ran the tests: the names of everything that failed need not travel
+# back, only the answer.
+class Evilution::Integration::KnownFailures
+  def initialize(ids)
+    @ids = ids.to_set
+  end
+
+  def empty?
+    @ids.empty?
+  end
+
+  # Whether failed_ids names at least one test, and none the baseline did not
+  # already see failing.
+  def only?(failed_ids)
+    !failed_ids.empty? && failed_ids.all? { |id| @ids.include?(id) }
+  end
+end

data/lib/evilution/integration/loading/body_call_neutralizer.rb

@@ -2,6 +2,11 @@
 
 require "prism"
 require_relative "../loading"
+require_relative "../../ast/aasm_declaration"
+require_relative "../../ast/included_block"
+require_relative "../../ast/callback_declaration"
+require_relative "callback_redeclaration"
+require_relative "concern_redeclaration"
 
 # Strip non-idempotent class/module-body side-effect calls from a mutated
 # source before re-eval. Such calls (e.g. dry-monads `register_mixin`, plugin
@@ -14,8 +19,9 @@ require_relative "../loading"
 # or module body (not inside a def). Calls on a small allowlist of patterns
 # known to be idempotent (`include`, `attr_*`, visibility modifiers, etc.)
 # are preserved; everything else has its source range replaced with `()`.
-# The replacement is shorter than the call it replaces, so edits are applied
-# from the end of the source backwards to keep earlier offsets valid.
+# A call spanning several lines leaves its line breaks behind, so the source
+# keeps its line count. Edits are applied from the end of the source backwards
+# to keep earlier offsets valid.
 class Evilution::Integration::Loading::BodyCallNeutralizer
   IDEMPOTENT_CALLS = %i[
     include extend prepend using
@@ -33,6 +39,11 @@ class Evilution::Integration::Loading::BodyCallNeutralizer
   # to nil without the warning on every supported Ruby (`(nil)` still warns on 3.3).
   REPLACEMENT = "()"
 
+  REDECLARATION = "::Evilution::Integration::Loading::ConcernRedeclaration"
+  GUARD = "#{REDECLARATION}.skipping? or ".freeze
+  REDECLARE = "; #{REDECLARATION}.call(self)".freeze
+  CALLBACKS = "::Evilution::Integration::Loading::CallbackRedeclaration"
+
   class << self
     attr_writer :preloaded_features
 
@@ -60,13 +71,33 @@ class Evilution::Integration::Loading::BodyCallNeutralizer
   # strips method definitions that subsequent sibling statements (alias, etc.)
   # depend on, producing cascading NameError. Callers that don't pass a path
   # get the legacy always-neutralize behavior.
-  def call(source, file_path: nil)
+  #
+  # `keep_offset` (optional) spares the one class-body call whose source
+  # contains that byte offset: a mutation inside a scope body only takes
+  # effect if the mutated file re-runs that `scope` call to replace it.
+  # When that call is an `aasm` machine, only the `event` or `state` holding
+  # the offset is spared inside its block: re-running one declaration replaces
+  # it, while re-running the whole machine would register its
+  # `after_all_transitions`-style callbacks a second time.
+  # When it is a concern's `included` block, the block is kept whole, since
+  # classes that include the concern later run all of it; every other call in
+  # it is guarded and the block is followed by a ConcernRedeclaration call,
+  # which re-declares the spared statement alone on the classes that include
+  # the concern already. Both are added on existing lines, so no line moves.
+  # An `aasm` machine inside such a block is treated the same way one level
+  # down: its other declarations are guarded, not blanked.
+  # When it is a callback declaration (`validate ... if: -> { }`), it is
+  # wrapped in a CallbackRedeclaration call, which puts what the re-run
+  # registers in the place of what the declaration registered before.
+  # `keep_lines` is where that was: the declaration's lines in the file as it
+  # was loaded.
+  def call(source, file_path: nil, keep_offset: nil, keep_lines: nil)
     return source if file_path && !preloaded?(file_path)
 
     result = Prism.parse(source)
     return source if result.failure?
 
-    edits = collect_edits(result.value)
+    edits = collect_edits(source, result.value, keep_offset, keep_lines)
     return source if edits.empty?
 
     apply_edits(source, edits)
@@ -78,26 +109,29 @@ class Evilution::Integration::Loading::BodyCallNeutralizer
     self.class.preloaded_features.include?(File.expand_path(file_path))
   end
 
-  def collect_edits(tree)
+  def collect_edits(source, tree, keep_offset, keep_lines)
     edits = []
-    walker = Walker.new(IDEMPOTENT_CALLS, edits)
+    walker = Walker.new(source, IDEMPOTENT_CALLS, edits, keep_offset, keep_lines)
     walker.visit(tree)
     edits
   end
 
   def apply_edits(source, edits)
     bytes = source.b
-    edits.sort_by!(&:first).reverse_each do |start_offset, end_offset|
-      bytes[start_offset, end_offset - start_offset] = REPLACEMENT
+    edits.sort_by!(&:first).reverse_each do |start_offset, end_offset, replacement|
+      bytes[start_offset, end_offset - start_offset] = replacement.b
     end
     bytes.force_encoding(source.encoding)
   end
 
   class Walker < Prism::Visitor
-    def initialize(allowlist, edits)
+    def initialize(source, allowlist, edits, keep_offset, keep_lines)
       super()
+      @source = source
       @allowlist = allowlist
       @edits = edits
+      @keep_offset = keep_offset
+      @keep_lines = keep_lines
     end
 
     def visit_class_node(node)
@@ -126,14 +160,99 @@ class Evilution::Integration::Loading::BodyCallNeutralizer
       return unless body_node.is_a?(Prism::StatementsNode)
 
       body_node.body.each do |stmt|
-        next unless stmt.is_a?(Prism::CallNode)
-        next if @allowlist.include?(stmt.name)
-        next if stmt.receiver && !stmt.receiver.is_a?(Prism::SelfNode)
+        next unless neutralizable?(stmt)
+
+        edit = edit_for(stmt)
+        if kept?(edit)
+          scan_kept(stmt)
+        else
+          @edits << edit
+        end
+      end
+    end
+
+    def scan_kept(stmt)
+      scan_machine(stmt)
+      scan_included(stmt)
+      wrap_callbacks(stmt)
+    end
+
+    # A kept callback declaration runs inside a block handed to
+    # CallbackRedeclaration, opened and closed on the declaration's own lines.
+    def wrap_callbacks(stmt)
+      return unless @keep_lines && Evilution::AST::CallbackDeclaration.match?(stmt)
+
+      start_offset = stmt.location.start_offset
+      end_offset = stmt.location.end_offset
+      lines = "#{@keep_lines.first}..#{@keep_lines.last}"
+      @edits << [start_offset, start_offset, "#{CALLBACKS}.call(self, __FILE__, #{lines}) { "]
+      @edits << [end_offset, end_offset, " }"]
+    end
+
+    # A kept `included` block stays whole. Its other calls are guarded rather
+    # than blanked, and what follows it re-declares the spared one on the
+    # classes that include the concern already.
+    def scan_included(stmt)
+      block = Evilution::AST::IncludedBlock.of(stmt)
+      return unless block && block.body.is_a?(Prism::StatementsNode)
+
+      guard_others(block)
+      end_offset = stmt.location.end_offset
+      @edits << [end_offset, end_offset, REDECLARE]
+    end
 
-        @edits << [stmt.location.start_offset, replacement_end_offset(stmt)]
+    # Guards every call of a block but the one holding the offset. When that
+    # one is an `aasm` machine, its own declarations are guarded the same way
+    # rather than blanked: a class that includes the concern later needs the
+    # whole machine, and one that includes it already only the mutated event.
+    # When it is a callback declaration, it is wrapped as it would be in a
+    # class body: the block runs as the including class, so that is whose
+    # chains CallbackRedeclaration rebuilds.
+    def guard_others(block)
+      block.body.body.grep(Prism::CallNode).each do |call|
+        if kept?(edit_for(call))
+          machine = Evilution::AST::AasmDeclaration.machine_block(call)
+          guard_others(machine) if machine && machine.body.is_a?(Prism::StatementsNode)
+          wrap_callbacks(call)
+        else
+          start_offset = call.location.start_offset
+          @edits << [start_offset, start_offset, GUARD]
+        end
       end
     end
 
+    def neutralizable?(stmt)
+      return false unless stmt.is_a?(Prism::CallNode)
+      return false if @allowlist.include?(stmt.name)
+
+      stmt.receiver.nil? || stmt.receiver.is_a?(Prism::SelfNode)
+    end
+
+    # Inside a kept `aasm` block every call is a declaration of the machine,
+    # so all of them but the one holding the offset go.
+    def scan_machine(stmt)
+      block = Evilution::AST::AasmDeclaration.machine_block(stmt)
+      return unless block && block.body.is_a?(Prism::StatementsNode)
+
+      block.body.body.grep(Prism::CallNode).each do |declaration|
+        edit = edit_for(declaration)
+        @edits << edit unless kept?(edit)
+      end
+    end
+
+    # The lines a blanked call took up are kept as empty lines: everything
+    # after it then sits on the line it has in the file, which is where a proc
+    # created by this source says it was written.
+    def edit_for(call)
+      start_offset = call.location.start_offset
+      end_offset = replacement_end_offset(call)
+      [start_offset, end_offset, REPLACEMENT + ("\n" * @source.byteslice(start_offset...end_offset).count("\n"))]
+    end
+
+    def kept?((start_offset, end_offset, _replacement))
+      @keep_offset && @keep_offset >= start_offset && @keep_offset < end_offset
+    end
+
     # Prism CallNode location ends at the close of the call syntax (e.g. the
     # closing `)` or the `<<~MARKER` opener for a heredoc argument). It does
     # NOT include the heredoc body lines or the trailing terminator. Replacing

data/lib/evilution/integration/loading/callback_redeclaration.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Runs a callback declaration again and puts what it registers where the
+# callbacks it registered before were.
+#
+# ActiveSupport::Callbacks does not replace on re-declaration. A callback
+# named by a symbol is dropped and added again at the end of its chain; one
+# that is a block or an object (a validator) is simply added, next to the
+# first. Either way a mutated `if:` would run in a chain that is no longer
+# the one the class was written with -- reordered, or with the unmutated
+# original still answering.
+#
+# So the chains are read before the declaration runs and rebuilt afterwards:
+# the callbacks this declaration registered last time give their place to the
+# new ones, and everything else stays where it was, including what subclasses
+# added themselves. See BodyCallNeutralizer for the source that calls this.
+#
+# "Last time" is the file's own load the first time round, and those
+# callbacks are recognised by where their procs were written (or by having
+# been dropped as duplicates). After that the module goes by what it
+# registered itself: a mutation can add or remove lines, so a proc created by
+# the mutated source may report a line that belongs to another declaration of
+# the real file.
+module Evilution::Integration::Loading::CallbackRedeclaration
+  CONDITIONS = %i[@if @unless].freeze
+  private_constant :CONDITIONS
+
+  # klass: the class whose body the declaration is written in. file, lines:
+  # where the declaration is in the file as it was loaded.
+  def self.call(klass, file, lines)
+    return yield unless klass.respond_to?(:__callbacks)
+
+    before = klass.__callbacks.transform_values(&:to_a)
+    result = yield
+    swaps = Settlement.new(klass, Origin.new(file, lines), registered).call(before)
+    swap_validators(klass, swaps)
+    result
+  end
+
+  # What earlier calls registered, by declaration:
+  # { [class, file, first line] => callbacks }.
+  def self.registered
+    @registered ||= {}
+  end
+
+  # `validates` also lists its validator for reflection (`Model.validators`),
+  # once per class; the old one is exchanged for the new there too.
+  def self.swap_validators(klass, swaps)
+    return unless klass.respond_to?(:_validators)
+
+    pairs = swaps.select { |old, new| old && new }.map { |old, new| [old.filter, new.filter] }
+    [klass, *descendants(klass)].each do |target|
+      target._validators.each_value do |validators|
+        pairs.each { |old, new| exchange(validators, old, new) }
+      end
+    end
+  end
+
+  def self.exchange(validators, old, new)
+    return unless validators.any? { |validator| validator.equal?(old) }
+
+    validators.reject! { |validator| validator.equal?(new) }
+    validators[validators.index { |validator| validator.equal?(old) }] = new
+  end
+
+  def self.descendants(klass)
+    klass.subclasses.flat_map { |subclass| [subclass, *descendants(subclass)] }
+  end
+
+  private_class_method :registered, :swap_validators, :exchange, :descendants
+
+  # Callbacks are told apart by identity throughout: two that compare equal
+  # are still two registrations.
+  module Identity
+    def self.member?(callbacks, callback)
+      callbacks.any? { |candidate| candidate.equal?(callback) }
+    end
+
+    def self.without(callbacks, others)
+      callbacks.reject { |callback| member?(others, callback) }
+    end
+  end
+  private_constant :Identity
+
+  # Rebuilds the chains of a class and its descendants after one declaration
+  # has run again.
+  class Settlement
+    def initialize(klass, origin, registered)
+      @klass = klass
+      @origin = origin
+      @registered = registered
+      @key = [klass, origin.file, origin.lines.first]
+    end
+
+    # before: { chain name => callbacks } as they were. Returns [old, new]
+    # callback pairs for what changed hands.
+    def call(before)
+      previous = @registered[@key]
+      mine = []
+      swaps = before.flat_map do |name, callbacks|
+        stale, fresh = settle(name, callbacks, previous)
+        mine.concat(fresh)
+        stale.zip(fresh)
+      end
+      @registered[@key] = mine unless mine.empty?
+      swaps
+    end
+
+    private
+
+    def settle(name, before, previous)
+      after = @klass.__callbacks[name].to_a
+      fresh = Identity.without(after, before)
+      return [[], []] if fresh.empty?
+
+      stale = before.select { |callback| stale?(callback, previous) || !Identity.member?(after, callback) }
+      order = reorder(before, stale, fresh)
+      @klass.send(:__update_callbacks, name) { |target, chain| rebuild(target, name, chain, order, after) }
+      [stale, fresh]
+    end
+
+    # What this declaration registered before: what an earlier call recorded
+    # or, the first time, what was written on its lines -- unless an earlier
+    # call for another declaration put it there.
+    def stale?(callback, previous)
+      return Identity.member?(previous, callback) if previous
+
+      @origin.declared?(callback) && !Identity.member?(@registered.values.flatten, callback)
+    end
+
+    # The new callbacks take the place of the first old one; with no old one
+    # to replace they stay where the declaration put them, at the end.
+    def reorder(before, stale, fresh)
+      return before + fresh if stale.empty?
+
+      before.flat_map do |callback|
+        next fresh if callback.equal?(stale.first)
+
+        Identity.member?(stale, callback) ? [] : [callback]
+      end
+    end
+
+    def rebuild(target, name, chain, order, after)
+      own = Identity.without(chain.to_a, after)
+      chain.clear
+      (order + own).each { |callback| chain.append(callback) }
+      target.send(:set_callbacks, name, chain)
+    end
+  end
+  private_constant :Settlement
+
+  # Where a declaration is written, and whether a callback came from there.
+  class Origin
+    attr_reader :file, :lines
+
+    def initialize(file, lines)
+      @file = canonical(file)
+      @lines = lines
+    end
+
+    def declared?(callback)
+      procs_of(callback).any? { |callable| here?(callable.source_location) }
+    end
+
+    private
+
+    def procs_of(callback)
+      conditions = CONDITIONS.flat_map { |ivar| Array(callback.instance_variable_get(ivar)) }
+      [callback.filter, *conditions].grep(Proc)
+    end
+
+    def here?(location)
+      !location.nil? && canonical(location.first) == @file && @lines.cover?(location.last)
+    end
+
+    # The same file may have been loaded through a symlinked path.
+    def canonical(path)
+      File.realpath(path)
+    rescue SystemCallError
+      File.expand_path(path)
+    end
+  end
+  private_constant :Origin
+end

data/lib/evilution/integration/loading/concern_redeclaration.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Re-declares one statement of a concern's `included` block on the classes
+# that already include the concern.
+#
+# A mutation inside `included do ... scope :published, -> { } ... end` has two
+# audiences. Classes that include the concern later run the whole block, so
+# registering the mutated block is enough for them. Classes that already
+# include it ran the original, and running the whole block on them again
+# would add its validations and callbacks a second time.
+#
+# So the source evilution evaluates guards every other call of the block with
+# `skipping?` and ends the block with `call(self)`: the block is run once more
+# on each existing includer with the guard up, and only the mutated
+# declaration takes effect there. See BodyCallNeutralizer.
+module Evilution::Integration::Loading::ConcernRedeclaration
+  KEY = :evilution_concern_redeclaration
+  INCLUDED_BLOCK = :@_included_block
+
+  # Called through UnboundMethods: ObjectSpace hands over every class in the
+  # VM, and one that defines `include?` or `superclass` of its own for its
+  # own purposes must not be asked that question.
+  INCLUDES = Module.instance_method(:include?)
+  SUPERCLASS = Class.instance_method(:superclass)
+  SINGLETON = Module.instance_method(:singleton_class?)
+  private_constant :KEY, :INCLUDED_BLOCK, :INCLUDES, :SUPERCLASS, :SINGLETON
+
+  def self.skipping?
+    Thread.current[KEY] == true
+  end
+
+  def self.call(concern)
+    return unless concern.instance_variable_defined?(INCLUDED_BLOCK)
+
+    block = concern.instance_variable_get(INCLUDED_BLOCK)
+    includers(concern).each { |klass| redeclare(klass, block) }
+  end
+
+  # The classes that include the concern themselves; a subclass inherits what
+  # its parent declares.
+  def self.includers(concern)
+    ObjectSpace.each_object(Class).select do |klass|
+      next false if SINGLETON.bind_call(klass) || !INCLUDES.bind_call(klass, concern)
+
+      parent = SUPERCLASS.bind_call(klass)
+      parent.nil? || !INCLUDES.bind_call(parent, concern)
+    end
+  end
+
+  def self.redeclare(klass, block)
+    previous = Thread.current[KEY]
+    Thread.current[KEY] = true
+    klass.class_eval(&block)
+  ensure
+    Thread.current[KEY] = previous
+  end
+
+  private_class_method :includers, :redeclare
+end