evilution 0.29.0 → 0.30.0

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

@@ -14,8 +14,31 @@ class Evilution::Mutator::Operator::SplatOperator < Evilution::Mutator::Base
     super
   end
 
+  # KeywordHashNode wraps call-arg kwargs + `**splat`. When an explicit
+  # `k: v` precedes a `**opts` splat in the same call, demoting `**opts` to
+  # bare `opts` puts a positional after a keyword and Ruby rejects it
+  # (`bar(k: v, opts)` is a syntax error). Mark such splats so
+  # `visit_assoc_splat_node` skips them. Splats that come BEFORE any kwarg
+  # (`bar(**opts, k: v)`) are still safe — positional-before-keyword is fine.
+  def visit_keyword_hash_node(node)
+    seen_kwarg = false
+    node.elements.each do |el|
+      if el.is_a?(Prism::AssocSplatNode) && seen_kwarg
+        kwarg_preceded_splats.add(el)
+      elsif el.is_a?(Prism::AssocNode)
+        seen_kwarg = true
+      end
+    end
+
+    super
+  end
+
   def visit_assoc_splat_node(node)
-    mutate_remove_double_splat(node) if node.value && !hash_elements.include?(node)
+    return super if node.value.nil?
+    return super if hash_elements.include?(node)
+    return super if kwarg_preceded_splats.include?(node)
+
+    mutate_remove_double_splat(node)
 
     super
   end
@@ -26,6 +49,10 @@ class Evilution::Mutator::Operator::SplatOperator < Evilution::Mutator::Base
     @hash_elements ||= Set.new.compare_by_identity
   end
 
+  def kwarg_preceded_splats
+    @kwarg_preceded_splats ||= Set.new.compare_by_identity
+  end
+
   def mutate_remove_splat(node)
     add_mutation(
       offset: node.location.start_offset,

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

@@ -9,9 +9,62 @@ class Evilution::Mutator::Operator::StringLiteral < Evilution::Mutator::Base
   end
 
   def visit_interpolated_string_node(node)
-    return super unless node.heredoc?
-    return if @skip_heredoc_literals
+    if node.heredoc?
+      return if @skip_heredoc_literals
 
+      node.parts.each do |part|
+        next if part.is_a?(Prism::StringNode)
+
+        visit(part)
+      end
+      return
+    end
+
+    # Adjacent-string concatenation — both `"foo" "bar"` and the line-continued
+    # form `"foo" \\\n "bar"` — lands in an InterpolatedStringNode whose parts
+    # are all StringNodes. Mutating chunks individually splices the wrong span:
+    # for the continued form Ruby treats `nil \\\n "rest"` as a confusing
+    # parse rather than a clean nil; for both forms the result is one StringNode
+    # plus an orphaned adjacent literal, not a meaningful mutation of the whole
+    # expression. Replace the entire concatenation in one shot instead.
+    if adjacent_string_concat?(node)
+      emit_string_mutations(node)
+      return
+    end
+
+    super
+  end
+
+  def visit_string_node(node)
+    return super if node.heredoc?
+
+    emit_string_mutations(node)
+
+    super
+  end
+
+  # Inner StringNode chunks of an interpolated symbol (`:"visit_#{type}"`),
+  # interpolated regular expression (`/^#{needle}/`), or interpolated x-string
+  # (`` `echo #{cmd}` ``) are not free string literals — they are fragments of
+  # a different literal kind. Mutating them splices empty-string bytes into the
+  # middle of a `:"..."` / `/.../` / `` `...` `` token, producing unparseable
+  # code. Visit only the interpolation parts (which may contain mutatable
+  # expressions); skip the raw StringNode chunks.
+  def visit_interpolated_symbol_node(node)
+    visit_non_string_parts(node)
+  end
+
+  def visit_interpolated_regular_expression_node(node)
+    visit_non_string_parts(node)
+  end
+
+  def visit_interpolated_x_string_node(node)
+    visit_non_string_parts(node)
+  end
+
+  private
+
+  def visit_non_string_parts(node)
     node.parts.each do |part|
       next if part.is_a?(Prism::StringNode)
 
@@ -19,10 +72,30 @@ class Evilution::Mutator::Operator::StringLiteral < Evilution::Mutator::Base
     end
   end
 
-  def visit_string_node(node)
-    return super if node.heredoc?
+  # Adjacent-string concatenation differs from a single interpolated string by
+  # the shape of its parts: each adjacent chunk is a full quoted literal of its
+  # own — a StringNode or InterpolatedStringNode that owns its own opening
+  # quote (`opening_loc`). A plain interpolated string `"a #{x} b"` decomposes
+  # into chunk StringNodes (no `opening_loc`) interleaved with
+  # EmbeddedStatementsNode parts (whose `opening_loc` is the `#{` delimiter,
+  # not a quote). Requiring StringNode/InterpolatedStringNode AND `opening_loc`
+  # rejects pure-interpolation cases like `"#{a}#{b}"` (whose parts are all
+  # EmbeddedStatementsNodes) while accepting mixed plain+interpolated adjacency
+  # like `"foo" "bar #{x}"` and its line-continued cousin.
+  QUOTED_LITERAL_TYPES = [Prism::StringNode, Prism::InterpolatedStringNode].freeze
+  private_constant :QUOTED_LITERAL_TYPES
 
-    replacement = node.content.empty? ? '"mutation"' : '""'
+  def adjacent_string_concat?(node)
+    return false unless node.parts.length > 1
+
+    node.parts.all? do |part|
+      QUOTED_LITERAL_TYPES.any? { |type| part.is_a?(type) } && part.opening_loc
+    end
+  end
+
+  def emit_string_mutations(node)
+    empty = node_content_empty?(node)
+    replacement = empty ? '"mutation"' : '""'
 
     add_mutation(
       offset: node.location.start_offset,
@@ -37,7 +110,11 @@ class Evilution::Mutator::Operator::StringLiteral < Evilution::Mutator::Base
       replacement: "nil",
       node: node
     )
+  end
 
-    super
+  def node_content_empty?(node)
+    return node.content.empty? if node.is_a?(Prism::StringNode)
+
+    node.parts.all? { |part| part.is_a?(Prism::StringNode) && part.content.empty? }
   end
 end

data/lib/evilution/mutator/registry.rb

@@ -39,11 +39,13 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::SymbolLiteral,
       Evilution::Mutator::Operator::ConditionalNegation,
       Evilution::Mutator::Operator::ConditionalBranch,
+      Evilution::Mutator::Operator::LastExpressionRemoval,
       Evilution::Mutator::Operator::StatementDeletion,
       Evilution::Mutator::Operator::MethodBodyReplacement,
       Evilution::Mutator::Operator::NegationInsertion,
       Evilution::Mutator::Operator::ReturnValueRemoval,
       Evilution::Mutator::Operator::CollectionReplacement,
+      Evilution::Mutator::Operator::ArgumentMethodCallReplacement,
       Evilution::Mutator::Operator::MethodCallRemoval,
       Evilution::Mutator::Operator::ArgumentRemoval,
       Evilution::Mutator::Operator::BlockRemoval,

data/lib/evilution/reporter/cli/line_formatters/error_rate_warning.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+# EV-nrgw / GH #1168: Score is `killed / score_denominator` where
+# `score_denominator = total - errors - neutral - equivalent - unresolved -
+# unparseable` — errors are excluded from the denominator entirely. A run
+# can read PASS at 100% while 16 of 19 mutations silently errored. This
+# formatter surfaces a warning right under the metrics block when the error
+# rate crosses the threshold so the silent failure mode becomes loud.
+class Evilution::Reporter::CLI::LineFormatters::ErrorRateWarning
+  DEFAULT_THRESHOLD = 0.25
+
+  def initialize(threshold: DEFAULT_THRESHOLD)
+    @threshold = threshold
+  end
+
+  def format(summary)
+    return nil if summary.total.zero?
+    return nil if summary.errors.zero?
+
+    rate = summary.errors.to_f / summary.total
+    return nil if rate <= @threshold
+
+    pct = (rate * 100).round(1)
+    "! High error rate: #{summary.errors}/#{summary.total} (#{pct}%) mutations errored — " \
+      "score may be unreliable. See the \"Errored mutations:\" section for the underlying cause."
+  end
+end

data/lib/evilution/reporter/cli/metrics_block.rb

@@ -3,6 +3,7 @@
 require_relative "../cli"
 require_relative "line_formatters/mutations"
 require_relative "line_formatters/score"
+require_relative "line_formatters/error_rate_warning"
 require_relative "line_formatters/duration"
 require_relative "line_formatters/efficiency"
 require_relative "line_formatters/peak_memory"
@@ -11,6 +12,7 @@ class Evilution::Reporter::CLI::MetricsBlock
   DEFAULT_LINES = [
     Evilution::Reporter::CLI::LineFormatters::Mutations.new,
     Evilution::Reporter::CLI::LineFormatters::Score.new,
+    Evilution::Reporter::CLI::LineFormatters::ErrorRateWarning.new,
     Evilution::Reporter::CLI::LineFormatters::Duration.new,
     Evilution::Reporter::CLI::LineFormatters::Efficiency.new,
     Evilution::Reporter::CLI::LineFormatters::PeakMemory.new

data/lib/evilution/reporter/json.rb

@@ -5,6 +5,7 @@ require "time"
 require_relative "suggestion"
 
 require_relative "../reporter"
+require_relative "../session/schema"
 
 class Evilution::Reporter::JSON
   def initialize(suggest_tests: false, integration: :rspec)
@@ -19,6 +20,7 @@ class Evilution::Reporter::JSON
 
   def build_report(summary)
     report = {
+      schema_version: Evilution::Session::Schema::CURRENT_VERSION,
       version: Evilution::VERSION,
       timestamp: Time.now.iso8601,
       summary: build_summary(summary),

data/lib/evilution/result/mutation_result.rb

@@ -23,28 +23,34 @@ class Evilution::Result::MutationResult
     freeze
   end
 
+  # Positive type checks, not nil checks. EV-s5br / GH #1174: the
+  # nil_replacement mutator can swap a nil default into `false` (or some other
+  # non-typed value), and `nil?` then returns false, sending a missing method
+  # to the wrong receiver and crashing the parent worker. Asking the field
+  # explicitly whether it is the expected struct keeps the parent process
+  # alive and lets the mutation count as a measured (errored) result.
   def child_rss_kb
-    @memory.nil? ? nil : @memory.child_rss_kb
+    @memory.is_a?(Evilution::Result::MemoryStats) ? @memory.child_rss_kb : nil
   end
 
   def memory_delta_kb
-    @memory.nil? ? nil : @memory.memory_delta_kb
+    @memory.is_a?(Evilution::Result::MemoryStats) ? @memory.memory_delta_kb : nil
   end
 
   def parent_rss_kb
-    @memory.nil? ? nil : @memory.parent_rss_kb
+    @memory.is_a?(Evilution::Result::MemoryStats) ? @memory.parent_rss_kb : nil
   end
 
   def error_message
-    @error.nil? ? nil : @error.message
+    @error.is_a?(Evilution::Result::ErrorInfo) ? @error.message : nil
   end
 
   def error_class
-    @error.nil? ? nil : @error.klass
+    @error.is_a?(Evilution::Result::ErrorInfo) ? @error.klass : nil
   end
 
   def error_backtrace
-    @error.nil? ? nil : @error.backtrace
+    @error.is_a?(Evilution::Result::ErrorInfo) ? @error.backtrace : nil
   end
 
   def killed?

data/lib/evilution/runner/baseline_runner.rb

@@ -55,7 +55,11 @@ class Evilution::Runner::BaselineRunner
     return nil unless config.baseline? && subjects.any?
 
     log_start
-    baseline = Evilution::Baseline.new(timeout: config.timeout, **integration_class.baseline_options)
+    baseline = Evilution::Baseline.new(
+      timeout: config.timeout,
+      test_files: config.spec_files.empty? ? nil : config.spec_files,
+      **integration_class.baseline_options
+    )
     result = baseline.call(subjects)
     log_complete(result)
     result

data/lib/evilution/runner/isolation_resolver.rb

@@ -4,6 +4,7 @@ require_relative "../runner"
 require_relative "../isolation/fork"
 require_relative "../isolation/in_process"
 require_relative "../rails_detector"
+require_relative "../gem_detector"
 
 class Evilution::Runner::IsolationResolver
   PRELOAD_CANDIDATES = [
@@ -108,18 +109,52 @@ class Evilution::Runner::IsolationResolver
   end
 
   def resolve_preload_path
-    return resolve_explicit_preload(config.preload) if config.preload.is_a?(String)
+    return resolve_explicit_with_fallback(config.preload) if config.preload.is_a?(String)
 
     resolve_autodetected_preload
   end
 
-  def resolve_explicit_preload(path)
-    return path if File.file?(path)
+  # Explicit preload path resolution with auto-detect fallthrough under :fork.
+  # When the user-configured path is missing, surface a stderr warning naming
+  # the missing path and try the auto-detect chain so a stale .evilution.yml
+  # entry doesn't silently disable preloading. Fallthrough requires both
+  # :fork isolation AND a detected Rails root (otherwise the chain has nowhere
+  # to look and the explicit-missing error is raised directly).
+  def resolve_explicit_with_fallback(explicit)
+    return explicit if File.file?(explicit)
 
-    raise Evilution::ConfigError.new("preload file not found: #{path.inspect}", file: path)
+    raise_explicit_preload_missing(explicit) unless can_fallthrough_to_autodetect?
+
+    warn_missing_explicit_preload(explicit)
+    fallback = find_first_existing_candidate
+    return fallback if fallback
+
+    raise build_combined_missing_error(explicit)
+  end
+
+  def can_fallthrough_to_autodetect?
+    resolve_isolation == :fork && !detected_rails_root.nil?
   end
 
   def resolve_autodetected_preload
+    if detected_rails_root
+      fallback = find_first_existing_candidate
+      return fallback if fallback
+
+      raise Evilution::ConfigError, autodetect_missing_message
+    end
+
+    detected_gem_entry
+  end
+
+  def detected_gem_entry
+    return @detected_gem_entry if defined?(@detected_gem_entry)
+
+    root = Evilution::GemDetector.gem_root_for_any(target_files)
+    @detected_gem_entry = root && Evilution::GemDetector.gem_entry_for(root, target_paths: target_files)
+  end
+
+  def find_first_existing_candidate
     root = detected_rails_root
     return nil unless root
 
@@ -127,11 +162,37 @@ class Evilution::Runner::IsolationResolver
       abs = File.join(root, rel)
       return abs if File.file?(abs)
     end
+    nil
+  end
+
+  def autodetect_missing_message
+    "Preload file not found. Tried: [#{PRELOAD_CANDIDATES.join(", ")}]. " \
+      "Pass --preload <file> or set preload: in .evilution.yml. " \
+      "Use --no-preload (or preload: false) to disable preloading entirely."
+  end
 
-    raise Evilution::ConfigError,
-          "Preload file not found. Tried: [#{PRELOAD_CANDIDATES.join(", ")}]. " \
-          "Pass --preload <file> or set preload: in .evilution.yml. " \
-          "Use --no-preload (or preload: false) to disable preloading entirely."
+  def build_combined_missing_error(explicit)
+    Evilution::ConfigError.new(
+      "Preload file not found. Configured preload #{explicit.inspect} does not exist, " \
+      "and none of the auto-detect candidates exist either. " \
+      "Tried: [#{PRELOAD_CANDIDATES.join(", ")}]. " \
+      "Pass --preload <file> or set preload: in .evilution.yml. " \
+      "Use --no-preload (or preload: false) to disable preloading entirely.",
+      file: explicit
+    )
+  end
+
+  def raise_explicit_preload_missing(path)
+    raise Evilution::ConfigError.new("preload file not found: #{path.inspect}", file: path)
+  end
+
+  def warn_missing_explicit_preload(path)
+    return if config.quiet
+
+    $stderr.write(
+      "[evilution] warning: configured preload #{path.inspect} not found; " \
+      "falling through to auto-detect chain.\n"
+    )
   end
 
   # When the user explicitly requests InProcess on a Rails project, warn once

data/lib/evilution/runner/mutation_planner.rb

@@ -27,7 +27,8 @@ class Evilution::Runner::MutationPlanner
 
   def call(subjects)
     generation = generate(subjects)
-    disabled_filter = filter_disabled(generation.mutations)
+    deduped = deduplicate(generation.mutations)
+    disabled_filter = filter_disabled(deduped)
     disabled_mutations = compute_disabled_mutations(disabled_filter)
     sig_filter = filter_sig_blocks(disabled_filter.enabled)
     equivalent_filter = filter_equivalent(sig_filter.enabled)
@@ -59,6 +60,22 @@ class Evilution::Runner::MutationPlanner
     )
   end
 
+  # Two operators can independently emit the same byte-level mutation
+  # (statement_deletion deleting a trailing literal AND last_expression_removal
+  # producing the same result, for example). Running both is wasted compute
+  # and inflates the denominator. Key is (file_path, mutated_source) — two
+  # mutations producing the same resulting source are operationally identical
+  # regardless of operator name. Order-stable: first occurrence wins, so
+  # operator-name ordering in the registry determines which name surfaces.
+  def deduplicate(mutations)
+    seen = {}
+    mutations.each do |mutation|
+      key = [mutation.file_path, mutation.mutated_source]
+      seen[key] ||= mutation
+    end
+    seen.values
+  end
+
   def generate(subjects)
     filter = build_ignore_filter
     operator_options = build_operator_options

data/lib/evilution/session/schema.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../session"
+
+module Evilution::Session::Schema
+  CURRENT_VERSION = 1
+
+  module_function
+
+  # Validates the schema_version of a parsed session JSON Hash.
+  #
+  # Sessions written before schema_version was introduced (key absent
+  # entirely) are treated as CURRENT_VERSION — the JSON shape that defined
+  # version 1. A key that is explicitly present but null/non-positive/non-
+  # integer is rejected as invalid; "missing" and "corrupted" must not
+  # collapse into the same lenient bucket. A schema_version newer than this
+  # gem supports raises Evilution::Error with an explicit "upgrade the gem"
+  # message so future writers cannot be silently misread.
+  def validate!(data, source: nil)
+    return unless data.key?("schema_version") || data.key?(:schema_version)
+
+    raw = data.fetch("schema_version") { data[:schema_version] }
+    raise_invalid!(raw, source) unless raw.is_a?(Integer) && raw.positive?
+    return if raw <= CURRENT_VERSION
+
+    raise_future!(raw, source)
+  end
+
+  def raise_invalid!(value, source)
+    raise Evilution::Error,
+          "invalid schema_version #{value.inspect}#{location_clause(source)}: must be a positive Integer"
+  end
+
+  def raise_future!(value, source)
+    raise Evilution::Error,
+          "session file#{location_clause(source)} has schema_version #{value}, " \
+          "newer than this evilution gem supports (current: #{CURRENT_VERSION}). " \
+          "Upgrade the evilution gem."
+  end
+
+  def location_clause(source)
+    source ? " at #{source}" : ""
+  end
+end

data/lib/evilution/session/store.rb

@@ -6,6 +6,7 @@ require "time"
 require "fileutils"
 
 require_relative "../session"
+require_relative "schema"
 
 class Evilution::Session::Store
   DEFAULT_DIR = ".evilution/results"
@@ -38,7 +39,9 @@ class Evilution::Session::Store
   def load(path)
     raise Evilution::Error, "session file not found: #{path}" unless File.exist?(path)
 
-    JSON.parse(File.read(path))
+    data = JSON.parse(File.read(path))
+    Evilution::Session::Schema.validate!(data, source: path) if data.is_a?(Hash)
+    data
   end
 
   def gc(older_than:)
@@ -60,6 +63,7 @@ class Evilution::Session::Store
 
   def build_session_data(summary, now)
     {
+      schema_version: Evilution::Session::Schema::CURRENT_VERSION,
       version: Evilution::VERSION,
       timestamp: now.iso8601,
       git: git_context,

data/lib/evilution/version.rb

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

data/lib/evilution.rb

@@ -94,6 +94,8 @@ require_relative "evilution/mutator/operator/equality_to_identity"
 require_relative "evilution/mutator/operator/lambda_body"
 require_relative "evilution/mutator/operator/begin_unwrap"
 require_relative "evilution/mutator/operator/block_param_removal"
+require_relative "evilution/mutator/operator/last_expression_removal"
+require_relative "evilution/mutator/operator/argument_method_call_replacement"
 require_relative "evilution/mutator/registry"
 require_relative "evilution/equivalent"
 require_relative "evilution/equivalent/heuristic"