evilution 1.2.0 → 1.4.0

data/lib/evilution/config.rb

@@ -21,7 +21,7 @@ class Evilution::Config
     example_targeting_fallback: :full_file, example_targeting_strategy: :lexical,
     example_targeting_cache: { max_files: 50, max_blocks: 10_000 },
     quiet_children: false, quiet_children_dir: "tmp/evilution_children",
-    profile: :default, canary: true
+    profile: :default, canary: true, warmup: :none
   }.freeze
 
   attr_reader :target_files, :schema_version, :timeout, :format,
@@ -33,7 +33,7 @@ class Evilution::Config
               :fallback_to_full_suite, :preload, :spec_mappings, :spec_pattern,
               :example_targeting, :example_targeting_fallback, :example_targeting_strategy,
               :example_targeting_cache,
-              :spec_selector, :quiet_children, :quiet_children_dir, :profile, :canary
+              :spec_selector, :quiet_children, :quiet_children_dir, :profile, :canary, :warmup
 
   def initialize(**options)
     skip_file = options.delete(:skip_config_file) ? true : false
@@ -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
@@ -274,7 +275,7 @@ class Evilution::Config
 
   VALIDATED_ATTRS = %i[
     integration jobs fail_fast isolation ignore_patterns
-    hooks preload spec_mappings spec_pattern profile
+    hooks preload spec_mappings spec_pattern profile warmup
   ].freeze
   private_constant :VALIDATED_ATTRS
 
@@ -311,6 +312,7 @@ require_relative "config/validators/example_targeting_fallback"
 require_relative "config/validators/example_targeting_strategy"
 require_relative "config/validators/example_targeting_cache"
 require_relative "config/validators/profile"
+require_relative "config/validators/warmup"
 require_relative "config/builders"
 require_relative "config/builders/spec_resolver"
 require_relative "config/builders/spec_selector"

data/lib/evilution/coverage.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../evilution"
+require_relative "version"
 
 # Per-example line-coverage support: build a `source file:line -> [examples]`
 # map so mutation targeting can run exactly the examples that execute a line.

data/lib/evilution/coverage_example_filter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../evilution"
+require_relative "version"
 require_relative "coverage/map"
 
 # Per-mutation example targeting backed by a real line-coverage Map (EV-ndjd).

data/lib/evilution/diagnostic.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../evilution"
+require_relative "version"
 
 # Evilution's own advisory messages -- "no matching spec found", and the like.
 #

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

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

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 require "prism"
-require_relative "../evilution"
+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