evilution 1.0.0 → 1.2.0

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Flatten a destructuring group in a block's parameter list:
+# `pairs.each_with_index { |(key, value), index| ... }` becomes
+# `pairs.each_with_index { |key, value, index| ... }`.
+#
+# The two forms bind differently once the group has a sibling: given `[1, 2]`
+# and `3`, the grouped form binds key=1, value=2, index=3, while the flat form
+# binds key=[1, 2], value=3, index=nil. A survivor means nothing asserts the
+# shape of what the yielder hands over.
+#
+# A lone group is left alone. With one parameter and a single yielded array —
+# what `each` over pairs, and `Hash#each`, actually yield — both forms bind the
+# same values, so the mutation would be behaviour-preserving and survive every
+# suite. The forms do diverge there for a yielder that passes several values,
+# but which one a block is handed cannot be known from the source, and a
+# guaranteed survivor on the common idiom is the worse trade.
+#
+# Methods and lambdas are left alone as well: both bind by arity, so flattening
+# a group in their signatures raises ArgumentError at every call site instead of
+# changing how arguments are distributed.
+class Evilution::Mutator::Operator::BlockDestructuringExpansion < Evilution::Mutator::Base
+  def visit_block_node(node)
+    expand_groups(node)
+    super
+  end
+
+  private
+
+  def expand_groups(node)
+    parameters = node.parameters
+    return unless parameters.is_a?(Prism::BlockParametersNode)
+
+    inner = parameters.parameters
+    return unless inner.is_a?(Prism::ParametersNode)
+    return unless siblings?(inner)
+
+    groups(inner).each { |group| flatten_group(group) }
+  end
+
+  # Both lists can hold a destructuring group: `|(a, b), c|` puts it in
+  # requireds, `|*rest, (a, b)|` in posts.
+  def groups(parameters)
+    [*parameters.requireds, *parameters.posts].grep(Prism::MultiTargetNode)
+  end
+
+  def siblings?(parameters)
+    parameter_count(parameters) > 1
+  end
+
+  # Block-local variables (`|a; tmp|`) are not parameters and so are not
+  # siblings — they change nothing about how arguments bind.
+  def parameter_count(parameters)
+    [
+      *parameters.requireds,
+      *parameters.optionals,
+      parameters.rest,
+      *parameters.posts,
+      *parameters.keywords,
+      parameters.keyword_rest,
+      parameters.block
+    ].compact.length
+  end
+
+  # Only the group's own parentheses go; anything nested inside keeps its own.
+  # A group written in a block's parameter list always carries them — the
+  # parenthesis-free MultiTargetNode belongs to multiple assignment, which is
+  # not reachable from here.
+  def flatten_group(group)
+    lparen = group.lparen_loc
+    rparen = group.rparen_loc
+
+    inner_start = lparen.start_offset + lparen.length
+    add_mutation(
+      offset: group.location.start_offset,
+      length: group.location.length,
+      replacement: byteslice_source(inner_start, rparen.start_offset - inner_start),
+      node: group
+    )
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Drop the single parameter of a block: `users.each { |u| touch(u) }` becomes
+# `users.each { touch(u) }`.
+#
+# A block tolerates being handed more arguments than it declares, so the mutant
+# runs until the body reads the dropped name, where it raises NameError. A
+# survivor therefore means the block never ran on a path the suite asserts —
+# the collection was empty, or the call was stubbed away.
+#
+# Not to be confused with BlockParamRemoval, which removes a method's `&block`
+# parameter from its signature.
+#
+# Two shapes are deliberately left alone. A parameter the body never reads makes
+# the mutation behaviour-preserving, so it would survive every suite and report
+# a coverage gap that is not there. A lambda checks its arity, so dropping its
+# parameter raises ArgumentError on every call, whatever the body does.
+class Evilution::Mutator::Operator::BlockParameterDrop < Evilution::Mutator::Base
+  def visit_block_node(node)
+    drop_parameter(node)
+    super
+  end
+
+  private
+
+  def drop_parameter(node)
+    return unless droppable?(node)
+
+    location = node.parameters.location
+    leading = leading_space(location)
+
+    add_mutation(
+      offset: location.start_offset - leading,
+      length: location.length + leading,
+      replacement: "",
+      node: node
+    )
+  end
+
+  def droppable?(node)
+    parameters = node.parameters
+    return false unless parameters.is_a?(Prism::BlockParametersNode)
+    return false unless parameters.locals.empty?
+
+    names = single_parameter_names(parameters.parameters)
+    names.any? { |name| body_reads?(node.body, name) }
+  end
+
+  # The space the block keyword leaves in front of the parameters goes with
+  # them, so `{ |u| body }` mutates to `{ body }` and `do |u|` to `do` rather
+  # than leaving a double space or a trailing one.
+  def leading_space(location)
+    preceding = @file_source.byteslice(location.start_offset - 1, 1)
+    preceding == " " ? 1 : 0
+  end
+
+  # The names bound by a lone required parameter, which is either a plain name
+  # or a destructuring target (`|(key, value)|`). Anything else — a second
+  # parameter, an optional, a rest, a keyword, a block pass, or the implicit
+  # rest Prism reports for the trailing comma in `|key,|` — means this is not a
+  # single-parameter block, and numbered parameters carry no node to remove.
+  def single_parameter_names(parameters)
+    return [] unless parameters.is_a?(Prism::ParametersNode)
+    return [] unless parameters.requireds.length == 1
+    return [] unless other_parameters_absent?(parameters)
+
+    parameter_names(parameters.requireds.first)
+  end
+
+  # Post-required parameters are not checked: block syntax only produces them
+  # after a rest parameter, which is rejected here anyway.
+  def other_parameters_absent?(parameters)
+    parameters.optionals.empty? && parameters.keywords.empty? &&
+      parameters.rest.nil? && parameters.keyword_rest.nil? && parameters.block.nil?
+  end
+
+  def parameter_names(node)
+    case node
+    when Prism::RequiredParameterNode then [node.name.to_s]
+    when Prism::MultiTargetNode then node.lefts.flat_map { |child| parameter_names(child) }
+    else []
+    end
+  end
+
+  # An underscore-prefixed name announces a parameter that is not meant to be
+  # read, so it is treated as unused even where the body happens to mention it.
+  def body_reads?(body, name)
+    return false if name.start_with?("_")
+
+    Evilution::AST::LocalReads.new.call(body, name)
+  end
+end

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/forwarding_super_to_explicit.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Give a forwarding `super` an empty argument list: `def f(a); super; end`
+# becomes `def f(a); super(); end`.
+#
+# Bare `super` hands the parent whatever the method was called with; `super()`
+# hands it nothing. A survivor means the forwarded arguments never reach an
+# assertion — the parent ignores them, or nothing exercises what it does with
+# them. ZsuperRemoval only turns the same node into `nil`, which asks whether
+# the call happens rather than what it carries, and ExplicitSuperMutation works
+# the other direction, on a super that already lists its arguments.
+#
+# The enclosing method must declare something to forward. With no parameters
+# the two forms are identical, and so they are with only a block parameter:
+# `super()` still passes the block along, so nothing would change.
+class Evilution::Mutator::Operator::ForwardingSuperToExplicit < Evilution::Mutator::Base
+  KEYWORD_LENGTH = "super".length
+  private_constant :KEYWORD_LENGTH
+
+  def visit_def_node(node)
+    enclosing_methods.push(node)
+    super
+  ensure
+    enclosing_methods.pop
+  end
+
+  def visit_forwarding_super_node(node)
+    add_parentheses(node) if forwards_arguments?
+    super
+  end
+
+  private
+
+  # A stack, so a def nested in another method's body is answered with its own
+  # parameters rather than the outer method's.
+  def enclosing_methods
+    @enclosing_methods ||= []
+  end
+
+  # Traversal always starts at the subject's own def, so a forwarding super is
+  # never reached without one on the stack.
+  def forwards_arguments?
+    parameters = enclosing_methods.last.parameters
+    return false if parameters.nil?
+
+    !only_block_parameter?(parameters)
+  end
+
+  # `&blk` is forwarded either way, so it is not something `super()` drops.
+  # Post-required parameters are not checked: a signature only has them after a
+  # rest parameter, which the rest check already rejects.
+  def only_block_parameter?(parameters)
+    parameters.requireds.empty? && parameters.optionals.empty? && parameters.keywords.empty? &&
+      parameters.rest.nil? && parameters.keyword_rest.nil?
+  end
+
+  # The parentheses are inserted right after the keyword rather than replacing
+  # the node, whose span also covers a block written on the super.
+  def add_parentheses(node)
+    add_mutation(
+      offset: node.location.start_offset + KEYWORD_LENGTH,
+      length: 0,
+      replacement: "()",
+      node: node
+    )
+  end
+end

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/method_body_replacement.rb

@@ -46,9 +46,18 @@ class Evilution::Mutator::Operator::MethodBodyReplacement < Evilution::Mutator::
   # class has no parent implementation of the method. We emit it only when the
   # original body already calls super, using that as a heuristic that a super
   # target is intended in this context.
+  #
+  # The search stops at a nested def, whose super belongs to that method rather
+  # than to this one. Counting it would emit a super replacement for a method
+  # that may have no parent to call, and the mutant would raise NoMethodError on
+  # contact — a kill that proves nothing (EV-vk1f / GH #1625). A block is not a
+  # boundary: `values.each { super }` does call this method's parent.
+  # MethodBodyToSuper#calls_super? draws the same line.
   def body_calls_super?(node)
     return true if node.is_a?(Prism::SuperNode) || node.is_a?(Prism::ForwardingSuperNode)
 
-    node.child_nodes.any? { |child| child && body_calls_super?(child) }
+    node.child_nodes.any? do |child|
+      child && !child.is_a?(Prism::DefNode) && body_calls_super?(child)
+    end
   end
 end