evilution 0.35.0 → 1.1.0

data/lib/evilution/mutator/base.rb

@@ -3,10 +3,13 @@
 require "prism"
 
 require_relative "../mutator"
+require_relative "primitives"
 require_relative "../integration/loading/body_call_neutralizer"
 require_relative "../ast/heredoc_span"
 
 class Evilution::Mutator::Base < Prism::Visitor
+  include Evilution::Mutator::Primitives
+
   AffectedSlices = Data.define(:original, :mutated)
   private_constant :AffectedSlices
 
@@ -41,7 +44,12 @@ class Evilution::Mutator::Base < Prism::Visitor
 
   private
 
-  def add_mutation(offset:, length:, replacement:, node:)
+  # `skip_unparseable` makes the mutation vanish rather than be recorded when
+  # the surgery does not parse. Off by default: the point operators rely on
+  # unparseable bytes reaching the reporter as their own bucket. The shared
+  # primitives opt in, since a nil-ification or promotion that does not parse
+  # carries no signal.
+  def add_mutation(offset:, length:, replacement:, node:, skip_unparseable: false)
     return if @filter && @filter.skip?(node)
 
     # When the byte range opens a heredoc but stops at its inline anchor,
@@ -67,6 +75,8 @@ class Evilution::Mutator::Base < Prism::Visitor
     surgery = Evilution::AST::SourceSurgeon.apply(
       @file_source, offset: offset, length: length, replacement: replacement
     )
+    return if skip_unparseable && surgery.unparseable?
+
     slices = slice_affected_lines(
       mutated_source: surgery.source,
       offset: offset,
@@ -74,7 +84,9 @@ class Evilution::Mutator::Base < Prism::Visitor
       replacement_bytesize: replacement.bytesize
     )
 
-    @mutations << build_mutation_record(node, surgery, slices)
+    mutation = build_mutation_record(node, surgery, slices)
+    @mutations << mutation
+    mutation
   end
 
   def build_mutation_record(node, surgery, slices)

data/lib/evilution/mutator/operator/boolean_expression_to_nil.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a whole compound boolean with `nil`: `a && b` becomes `nil`, and
+# the same for `||` and the `and` / `or` keyword forms.
+#
+# Where BooleanOperandPromotion drops one side, this drops both. The
+# survivor it targets is a condition whose value is never asserted — code
+# that runs the expression for its side effects, or a test that only checks
+# the branch was taken rather than what the branch was given.
+class Evilution::Mutator::Operator::BooleanExpressionToNil < Evilution::Mutator::Base
+  def visit_and_node(node)
+    mutate_to_nil(node)
+    super
+  end
+
+  def visit_or_node(node)
+    mutate_to_nil(node)
+    super
+  end
+end

data/lib/evilution/mutator/operator/boolean_operand_promotion.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Drop one side of a compound boolean: `a && b` becomes `a` and `b`, and the
+# same for `||` (both the symbol and the `and` / `or` keyword forms).
+#
+# BooleanOperatorReplacement swaps the operator but always keeps both
+# operands, so a test that only ever exercises one side of a condition
+# survives it. Promoting an operand kills exactly those tests.
+class Evilution::Mutator::Operator::BooleanOperandPromotion < Evilution::Mutator::Base
+  def visit_and_node(node)
+    promote_operands(node)
+    super
+  end
+
+  def visit_or_node(node)
+    promote_operands(node)
+    super
+  end
+
+  private
+
+  # Nested expressions need no special handling: `a && b && c` is an outer
+  # AndNode over an inner one, so the outer visit yields `a && b` and `c`
+  # while `super` descends and the inner visit yields `a && c` and `b`.
+  def promote_operands(node)
+    promote_child(node, node.left)
+    promote_child(node, node.right)
+  end
+end

data/lib/evilution/mutator/operator/case_in.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Drop one `in` clause from a `case/in`, leaving the rest of the arms in
+# place.
+#
+# Input that used to match the removed pattern now falls through to a later
+# arm, to the `else`, or -- with neither -- raises NoMatchingPatternError. A
+# survivor means the suite never exercises that arm, so its pattern could be
+# deleted outright without any test noticing.
+#
+# Pattern matching had no visitor at all before this operator: the case/in
+# grammar is a CaseMatchNode of InNodes, unrelated to the CaseNode/WhenNode
+# pair CaseWhen handles.
+class Evilution::Mutator::Operator::CaseIn < Evilution::Mutator::Base
+  def visit_case_match_node(node)
+    remove_in_clauses(node)
+    remove_else_branch(node)
+    super
+  end
+
+  private
+
+  # A case/in needs at least one arm to parse, so a lone clause stays put.
+  def remove_in_clauses(node)
+    return if node.conditions.length < 2
+
+    node.conditions.each do |in_node|
+      location = in_node.location
+
+      add_mutation(
+        offset: location.start_offset,
+        length: location.length,
+        replacement: "",
+        node: in_node
+      )
+    end
+  end
+
+  # Without an else, an unmatched value raises NoMatchingPatternError rather
+  # than falling through, so a survivor means nothing in the suite reaches the
+  # fallback.
+  #
+  # An empty else body is worth removing here, which is where this parts ways
+  # with CaseWhen: a case/when yields nil whether its else is empty or absent,
+  # but an empty case/in else yields nil while an absent one raises. Prism
+  # reports no statements for that shape, so the edit covers the keyword alone.
+  def remove_else_branch(node)
+    else_clause = node.else_clause
+    return if else_clause.nil?
+
+    keyword_location = else_clause.else_keyword_loc
+    statements = else_clause.statements
+    end_offset = statements.nil? ? keyword_location.end_offset : statements.location.end_offset
+
+    add_mutation(
+      offset: keyword_location.start_offset,
+      length: end_offset - keyword_location.start_offset,
+      replacement: "",
+      node: else_clause
+    )
+  end
+end

data/lib/evilution/mutator/operator/case_when.rb

@@ -5,7 +5,9 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::CaseWhen < Evilution::Mutator::Base
   def visit_case_node(node)
     remove_when_branches(node)
+    remove_when_conditions(node)
     replace_when_bodies(node)
+    raise_in_empty_when_bodies(node)
     remove_else_branch(node)
 
     super
@@ -26,9 +28,42 @@ class Evilution::Mutator::Operator::CaseWhen < Evilution::Mutator::Base
     end
   end
 
+  # `when a, b` matches on either value, so dropping the whole arm cannot tell
+  # which of them a test actually exercises. Shortening the list one value at a
+  # time can. WhenNode#conditions holds the values; the enclosing CaseNode's
+  # own #conditions holds the arms.
+  def remove_when_conditions(node)
+    node.conditions.each do |when_node|
+      values = when_node.conditions
+      next if values.length < 2
+
+      values.each_index do |index|
+        offset, length = condition_removal_span(values, index)
+
+        add_mutation(offset: offset, length: length, replacement: "", node: when_node)
+      end
+    end
+  end
+
+  # Each value has to take its separating comma with it, or the arm is left
+  # with a dangling one. The first value owns the comma that follows it; every
+  # later value owns the comma that precedes it. Taking whole byte ranges
+  # between value boundaries also sweeps up any newline the list wraps on.
+  def condition_removal_span(values, index)
+    if index.zero?
+      start_offset = values[0].location.start_offset
+      end_offset = values[1].location.start_offset
+    else
+      start_offset = values[index - 1].location.end_offset
+      end_offset = values[index].location.end_offset
+    end
+
+    [start_offset, end_offset - start_offset]
+  end
+
   def replace_when_bodies(node)
     node.conditions.each do |when_node|
-      next if when_node.statements.nil? || when_node.statements.body.empty?
+      next if empty_body?(when_node)
 
       add_mutation(
         offset: when_node.statements.location.start_offset,
@@ -39,6 +74,42 @@ class Evilution::Mutator::Operator::CaseWhen < Evilution::Mutator::Base
     end
   end
 
+  # An empty arm is a deliberate no-op, so there is no body to blank out --
+  # dropping the arm entirely is indistinguishable from falling through to a
+  # missing else. Inserting a raise is what proves the arm was selected.
+  def raise_in_empty_when_bodies(node)
+    node.conditions.each do |when_node|
+      next unless empty_body?(when_node)
+
+      indent = " " * (indentation_of(when_node.keyword_loc.start_offset) + 2)
+
+      add_mutation(
+        offset: body_insert_offset(when_node),
+        length: 0,
+        replacement: "\n#{indent}raise",
+        node: when_node
+      )
+    end
+  end
+
+  def empty_body?(when_node)
+    statements = when_node.statements
+    statements.nil? || statements.body.empty?
+  end
+
+  # `when 1, 2` puts the body after the last condition; `when 1 then` after the
+  # keyword. Prism reports a nil then_keyword_loc when the form omits it.
+  def body_insert_offset(when_node)
+    then_keyword_loc = when_node.then_keyword_loc
+    location = then_keyword_loc.nil? ? when_node.conditions.last.location : then_keyword_loc
+
+    location.start_offset + location.length
+  end
+
+  def indentation_of(offset)
+    offset - line_start_byte(@file_source, offset)
+  end
+
   def remove_else_branch(node)
     else_clause = node.else_clause
     return if else_clause.nil? || else_clause.statements.nil?

data/lib/evilution/mutator/operator/conditional_branch.rb

@@ -4,21 +4,34 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::ConditionalBranch < Evilution::Mutator::Base
   def visit_if_node(node)
-    return super unless node.statements
+    blank_branches(node, node.subsequent)
 
-    add_nil_mutation(node.statements, node)
-    add_nil_mutation_to_else(node.subsequent, node)
+    super
+  end
+
+  # Prism gives `unless` its own node type, and names the else slot
+  # `else_clause` rather than IfNode's `subsequent`. Everything below that is
+  # the same shape, so both forms share the branch handling.
+  def visit_unless_node(node)
+    blank_branches(node, node.else_clause)
 
     super
   end
 
   private
 
-  def add_nil_mutation_to_else(subsequent, node)
-    return unless subsequent.is_a?(Prism::ElseNode)
-    return if subsequent.statements.nil?
+  def blank_branches(node, else_clause)
+    return if node.statements.nil?
+
+    add_nil_mutation(node.statements, node)
+    add_nil_mutation_to_else(else_clause, node)
+  end
+
+  def add_nil_mutation_to_else(else_clause, node)
+    return unless else_clause.is_a?(Prism::ElseNode)
+    return if else_clause.statements.nil?
 
-    add_nil_mutation(subsequent.statements, node)
+    add_nil_mutation(else_clause.statements, node)
   end
 
   def add_nil_mutation(statements, node)

data/lib/evilution/mutator/operator/if_branch_swap.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace the if-branch with the else body and drop the else:
+# `if c; x; else; y; end` becomes `if c; y; end`.
+#
+# The condition still runs and still selects, but both of its outcomes
+# change: truthy now yields the else body, falsy now yields nil. That is out
+# of reach of the existing conditional operators — ConditionalNegation
+# pins the predicate to one branch, ConditionalBranch blanks a body to nil —
+# so this survives only when the suite never distinguishes the two branch
+# values from each other.
+class Evilution::Mutator::Operator::IfBranchSwap < Evilution::Mutator::Base
+  def visit_if_node(node)
+    swap_branches(node)
+    super
+  end
+
+  private
+
+  # The edit spans from the start of the if-branch to the end of the else
+  # body, which swallows the `else` keyword along with the original branch.
+  # It deliberately stops short of ElseNode#location, which runs on to the
+  # closing `end` the mutation needs to keep.
+  #
+  # `subsequent` is an IfNode rather than an ElseNode on an `elsif`, and
+  # nil on a bare `if`; neither has an else body to promote. A ternary does
+  # reach the edit, but `c ? y` does not parse, so add_mutation drops it.
+  def swap_branches(node)
+    else_node = node.subsequent
+    return unless else_node.is_a?(Prism::ElseNode)
+
+    then_statements = node.statements
+    else_statements = else_node.statements
+    return if then_statements.nil? || else_statements.nil?
+
+    offset = then_statements.location.start_offset
+
+    add_mutation(
+      offset: offset,
+      length: else_statements.location.end_offset - offset,
+      replacement: source_of(else_statements),
+      node: node,
+      skip_unparseable: true
+    )
+  end
+end

data/lib/evilution/mutator/operator/loop_body_to_raise.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a loop body with a bare `raise`: `while c; body; end` becomes
+# `while c; raise; end`.
+#
+# A survivor means no test ever enters the loop, so the body is either dead
+# or reached only by paths the suite never exercises. The raise terminates
+# the loop on its first iteration, which is what makes this safe where
+# body-to-nil is not: nil-ing a body that advances the predicate spins until
+# the per-mutation timeout (EV-170m.7).
+class Evilution::Mutator::Operator::LoopBodyToRaise < Evilution::Mutator::Base
+  def visit_while_node(node)
+    replace_body_with_raise(node)
+    super
+  end
+
+  def visit_until_node(node)
+    replace_body_with_raise(node)
+    super
+  end
+
+  private
+
+  def replace_body_with_raise(node)
+    statements = body_statements(node)
+    return if statements.nil?
+    return if bare_raise?(statements)
+
+    location = statements.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: "raise",
+      node: node
+    )
+  end
+
+  # A post-form loop (`begin ... end while c`) hangs its body off a BeginNode,
+  # and that node's own span is what WhileNode#statements reports. Editing the
+  # outer span would rewrite the loop as `raise while c`, which checks the
+  # predicate first and so no longer runs the body unconditionally -- exactly
+  # the property this mutation exists to probe. Reach through to the inner
+  # statements instead and leave `begin ... end while c` standing.
+  #
+  # begin_modifier? is set only for that post-form, where the grammar
+  # guarantees the single wrapped statement is the BeginNode.
+  def body_statements(node)
+    statements = node.statements
+    return statements unless node.begin_modifier?
+
+    statements.body.first.statements
+  end
+
+  # A body that already raises unconditionally would mutate to itself.
+  def bare_raise?(statements)
+    body = statements.body
+    return false unless body.length == 1
+
+    only = body.first
+    only.is_a?(Prism::CallNode) &&
+      only.name == :raise &&
+      only.arguments.nil? &&
+      only.receiver.nil?
+  end
+end

data/lib/evilution/mutator/operator/pattern_predicate.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a one-line pattern match with `false`: `x in Integer` becomes
+# `false`.
+#
+# The mutant differs from the original only on inputs the pattern actually
+# matches, so a survivor means no test ever feeds it a matching value -- the
+# true path of the predicate is unexercised.
+#
+# Only Prism::MatchPredicateNode is mutated. Its sibling MatchRequiredNode
+# (`x => Integer`) raises NoMatchingPatternError rather than returning a
+# boolean, so `false` would not stand in for it.
+class Evilution::Mutator::Operator::PatternPredicate < Evilution::Mutator::Base
+  def visit_match_predicate_node(node)
+    location = node.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: "false",
+      node: node
+    )
+
+    super
+  end
+end

data/lib/evilution/mutator/primitives.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../mutator"
+
+# Mutation shapes shared across the operator families: replacing an
+# expression with `nil`, and replacing an expression with the source of one
+# of its children. Both are built on Base#add_mutation, so the
+# equivalent-mutant filter and the heredoc-span guards still apply.
+#
+# Unlike a bare add_mutation call, these skip rather than emit when the
+# result would not parse in its surrounding context. A promotion that does
+# not parse is noise rather than signal, so it never reaches the
+# `unparseable` bucket the point operators still populate.
+module Evilution::Mutator::Primitives
+  private
+
+  # Replace `target`'s byte span with `nil`, attributing the mutation to
+  # `node`. `target` defaults to `node`; pass an inner node to nil out a body
+  # while keeping the reported location on the enclosing construct.
+  def mutate_to_nil(node, target: node)
+    replace_span(node: node, target: target, replacement: "nil")
+  end
+
+  # Replace `target`'s byte span with `child`'s source, verbatim. `child` may
+  # be nil — Prism leaves optional slots (a call's receiver, an if's else)
+  # empty — in which case there is nothing to promote.
+  def promote_child(node, child, target: node)
+    return nil if child.nil?
+
+    replace_span(node: node, target: target, replacement: source_of(child))
+  end
+
+  def replace_span(node:, target:, replacement:)
+    return nil if target.nil?
+
+    location = target.location
+    return nil if replacement == byteslice_source(location.start_offset, location.length)
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: replacement,
+      node: node,
+      skip_unparseable: true
+    )
+  end
+
+  def source_of(child)
+    location = child.location
+    byteslice_source(location.start_offset, location.length)
+  end
+end

data/lib/evilution/mutator/registry.rb

@@ -29,6 +29,8 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::ComparisonReplacement,
       Evilution::Mutator::Operator::ArithmeticReplacement,
       Evilution::Mutator::Operator::BooleanOperatorReplacement,
+      Evilution::Mutator::Operator::BooleanOperandPromotion,
+      Evilution::Mutator::Operator::BooleanExpressionToNil,
       Evilution::Mutator::Operator::BooleanLiteralReplacement,
       Evilution::Mutator::Operator::NilReplacement,
       Evilution::Mutator::Operator::IntegerLiteral,
@@ -39,6 +41,7 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::SymbolLiteral,
       Evilution::Mutator::Operator::ConditionalNegation,
       Evilution::Mutator::Operator::ConditionalBranch,
+      Evilution::Mutator::Operator::IfBranchSwap,
       Evilution::Mutator::Operator::LastExpressionRemoval,
       Evilution::Mutator::Operator::StatementDeletion,
       Evilution::Mutator::Operator::MethodBodyReplacement,
@@ -92,9 +95,12 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::DefinedCheck,
       Evilution::Mutator::Operator::RegexCapture,
       Evilution::Mutator::Operator::LoopFlip,
+      Evilution::Mutator::Operator::LoopBodyToRaise,
       Evilution::Mutator::Operator::StringInterpolation,
       Evilution::Mutator::Operator::RetryRemoval,
       Evilution::Mutator::Operator::CaseWhen,
+      Evilution::Mutator::Operator::CaseIn,
+      Evilution::Mutator::Operator::PatternPredicate,
       Evilution::Mutator::Operator::PredicateReplacement,
       Evilution::Mutator::Operator::EqualityToIdentity,
       Evilution::Mutator::Operator::LambdaBody,

data/lib/evilution/related_spec_heuristic.rb

@@ -31,14 +31,12 @@ class Evilution::RelatedSpecHeuristic
   def extract_domain(file_path)
     normalized = normalize_path(file_path)
 
-    # Strip common prefixes and get the relative path under app/ or lib/
     relative = normalized
                .delete_prefix("app/controllers/")
                .delete_prefix("app/models/")
                .delete_prefix("app/")
                .delete_prefix("lib/")
 
-    # Remove .rb extension and _controller suffix
     basename = relative.sub(/\.rb\z/, "")
     basename = basename.sub(/_controller\z/, "")
 

data/lib/evilution/runner.rb

@@ -3,6 +3,7 @@
 require "fileutils"
 require_relative "../evilution"
 
+# @api private
 class Evilution::Runner
   # Autoloaded: canary.rb subclasses Evilution::Error at class-body eval
   # time, which is not yet defined while evilution.rb is mid-load. Deferring

data/lib/evilution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evilution
-  VERSION = "0.35.0"
+  VERSION = "1.1.0"
 end

data/lib/evilution.rb

@@ -27,11 +27,14 @@ require_relative "evilution/mutator/operator/integer_literal"
 require_relative "evilution/mutator/operator/float_literal"
 require_relative "evilution/mutator/operator/nil_replacement"
 require_relative "evilution/mutator/operator/boolean_operator_replacement"
+require_relative "evilution/mutator/operator/boolean_operand_promotion"
+require_relative "evilution/mutator/operator/boolean_expression_to_nil"
 require_relative "evilution/mutator/operator/arithmetic_replacement"
 require_relative "evilution/mutator/operator/string_literal"
 require_relative "evilution/mutator/operator/array_literal"
 require_relative "evilution/mutator/operator/hash_literal"
 require_relative "evilution/mutator/operator/conditional_branch"
+require_relative "evilution/mutator/operator/if_branch_swap"
 require_relative "evilution/mutator/operator/symbol_literal"
 require_relative "evilution/mutator/operator/conditional_negation"
 require_relative "evilution/mutator/operator/negation_insertion"
@@ -85,9 +88,12 @@ require_relative "evilution/mutator/operator/splat_operator"
 require_relative "evilution/mutator/operator/defined_check"
 require_relative "evilution/mutator/operator/regex_capture"
 require_relative "evilution/mutator/operator/loop_flip"
+require_relative "evilution/mutator/operator/loop_body_to_raise"
 require_relative "evilution/mutator/operator/string_interpolation"
 require_relative "evilution/mutator/operator/retry_removal"
 require_relative "evilution/mutator/operator/case_when"
+require_relative "evilution/mutator/operator/case_in"
+require_relative "evilution/mutator/operator/pattern_predicate"
 require_relative "evilution/mutator/operator/predicate_replacement"
 require_relative "evilution/mutator/operator/predicate_to_nil"
 require_relative "evilution/mutator/operator/equality_to_identity"
@@ -129,6 +135,12 @@ require_relative "evilution/cli"
 require_relative "evilution/disable_comment"
 require_relative "evilution/runner"
 
+# Evilution has no public Ruby API. The entire `Evilution::` namespace is
+# internal and may change in any release, including patches. The stable,
+# SemVer-governed contract is the CLI, `.evilution.yml` config keys, session
+# JSON files, the MCP tool schemas, and process exit codes. See
+# docs/public_api.md and docs/versioning.md.
+# @api private
 module Evilution
   # Captured at load time, before any isolator can chdir into a per-mutation
   # sandbox. Used as the anchor for resolving project-relative paths (spec

data/scripts/compare_targeting

@@ -128,8 +128,10 @@ module CompareTargeting
     def lost_kills(mode = "coverage")
       full = @modes.fetch("full_file")
       other = @modes.fetch(mode)
-      full.keys.select { |key| full.status(key) == "killed" && other.status(key) != "killed" }
-               .map { |key| full.label(key) }
+      full
+        .keys
+        .select { |key| full.status(key) == "killed" && other.status(key) != "killed" }
+        .map { |key| full.label(key) }
     end
 
     def to_row(repo)