mutant 0.14.2 → 0.15.0

data/lib/mutant/mutator/node/conditional_loop.rb

@@ -7,7 +7,14 @@ module Mutant
       # Mutator for while expressions
       class ConditionalLoop < self
 
-        handle(:until, :while)
+        INVERSE = {
+          until:      :while,
+          until_post: :while_post,
+          while:      :until,
+          while_post: :until_post
+        }.freeze
+
+        handle(*INVERSE.keys)
 
         children :condition, :body
 
@@ -16,11 +23,33 @@ module Mutant
         def dispatch
           emit_singletons
           emit_condition_mutations
+          emit_type_swap
+          if post?
+            dispatch_post
+          else
+            dispatch_regular
+          end
+        end
+
+        def dispatch_post
+          emit_body_mutations { |node| node.type.equal?(:kwbegin) }
+          emit_body(s(:kwbegin, N_RAISE))
+        end
+
+        def dispatch_regular
           emit_body_mutations if body
           emit_body(nil)
           emit_body(N_RAISE)
         end
 
+        def post?
+          node.type.end_with?('_post')
+        end
+
+        def emit_type_swap
+          emit(s(INVERSE.fetch(node.type), *children))
+        end
+
       end # ConditionalLoop
     end # Node
   end # Mutator

data/lib/mutant/mutator/node/define.rb

@@ -6,6 +6,15 @@ module Mutant
       # Namespace for define mutations
       class Define < self
 
+        # Mapping from AST node types to their type-aware empty/default values
+        TYPE_TO_DEFAULT = {
+          array: N_EMPTY_ARRAY,
+          hash:  N_EMPTY_HASH,
+          str:   N_EMPTY_STRING,
+          int:   N_ZERO_INTEGER,
+          float: N_ZERO_FLOAT
+        }.freeze
+
       private
 
         def dispatch
@@ -13,6 +22,7 @@ module Mutant
           emit_optarg_body_assignments
           emit_body(N_RAISE)
           emit_body(N_ZSUPER)
+          emit_type_aware_defaults
 
           return if !body || ignore?(body)
 
@@ -21,6 +31,22 @@ module Mutant
           emit_body_mutations
         end
 
+        def emit_type_aware_defaults
+          return unless body
+
+          default_node = TYPE_TO_DEFAULT[return_expression.type]
+
+          emit_body(default_node) if default_node
+        end
+
+        def return_expression
+          if n_begin?(body)
+            body.children.last
+          else
+            body
+          end
+        end
+
         def emit_optarg_body_assignments
           arguments.children.each do |argument|
             next unless n_optarg?(argument) && AST::Meta::Optarg.new(node: argument).used?

data/lib/mutant/mutator/node/defined.rb

@@ -14,6 +14,7 @@ module Mutant
 
         def dispatch
           emit(N_NIL)
+          emit(N_TRUE)
           emit_instance_variable_mutation
         end
 

data/lib/mutant/mutator/node/ensure.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for ensure nodes
+      class Ensure < self
+
+        handle(:ensure)
+
+        children :body, :ensure_body
+
+      private
+
+        def dispatch
+          emit(body) if body
+          emit_body_mutations if body
+          emit_ensure_body_mutations if ensure_body
+        end
+
+      end # Ensure
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/guard.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for pattern match guard nodes (if_guard, unless_guard)
+      class Guard < self
+        handle(:if_guard, :unless_guard)
+
+        children :condition
+
+      private
+
+        def dispatch
+          emit_condition_mutations
+          emit_type(N_TRUE)
+          emit_type(N_FALSE)
+        end
+
+      end # Guard
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/in_pattern.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+
+      # Mutator for in pattern clauses
+      class InPattern < self
+
+        handle(:in_pattern)
+
+        children :pattern, :guard, :body
+
+      private
+
+        def dispatch
+          emit_pattern_mutations
+          emit_guard_mutations if guard
+          emit_body_mutations if body
+        end
+
+      end # InPattern
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/literal/complex.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for complex literals
+        class Complex < self
+
+          ONE = 1i
+
+          handle(:complex)
+
+          children :value
+
+        private
+
+          def dispatch
+            emit_singletons
+            emit_values
+          end
+
+          def values
+            [0i, ONE, value + ONE, value - ONE]
+          end
+
+        end # Complex
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/literal/rational.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for rational literals
+        class Rational < self
+
+          ONE = 1r
+
+          handle(:rational)
+
+          children :value
+
+        private
+
+          def dispatch
+            emit_singletons
+            emit_values
+          end
+
+          def values
+            [0r, ONE, value + ONE, value - ONE]
+          end
+
+        end # Rational
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/literal/string.rb

@@ -13,6 +13,7 @@ module Mutant
 
           def dispatch
             emit_singletons
+            emit(N_EMPTY_STRING)
           end
 
         end # String

data/lib/mutant/mutator/node/match_alt.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+
+      # Mutator for pattern alternation nodes
+      class MatchAlt < self
+
+        handle(:match_alt)
+
+        children :left, :right
+
+      private
+
+        def dispatch
+          emit(left)
+          emit(right)
+          emit_left_mutations
+          emit_right_mutations
+        end
+
+      end # MatchAlt
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/match_pattern_p.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+
+      # Mutator for `expr in pattern` predicate nodes
+      class MatchPatternP < self
+
+        handle(:match_pattern_p)
+
+        children :expression, :pattern
+
+      private
+
+        def dispatch
+          emit(N_FALSE)
+          emit_expression_mutations
+          emit_pattern_mutations
+        end
+
+      end # MatchPatternP
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/op_asgn.rb

@@ -11,14 +11,34 @@ module Mutant
 
         children :left, :operation, :right
 
+        OPERATOR_SWAPS = {
+          :+  => %i[-],
+          :-  => %i[+],
+          :*  => %i[/],
+          :/  => %i[*],
+          :%  => %i[/],
+          :** => %i[*],
+          :&  => %i[|],
+          :|  => %i[& ^],
+          :^  => %i[& |],
+          :<< => %i[>>],
+          :>> => %i[<<]
+        }.each_value(&:freeze).freeze
+
       private
 
         def dispatch
           left_mutations
-
+          emit_operator_replacements
           emit_right_mutations
         end
 
+        def emit_operator_replacements
+          OPERATOR_SWAPS.fetch(operation).each do |replacement|
+            emit_operation(replacement)
+          end
+        end
+
         def left_mutations
           emit_left_mutations do |node|
             !n_self?(node)

data/lib/mutant/mutator/node/or_asgn.rb

@@ -16,10 +16,7 @@ module Mutant
         def dispatch
           emit_singletons
           emit_right_mutations
-          return if n_ivasgn?(left)
-          emit_left_mutations do |node|
-            AST::Types::ASSIGNABLE_VARIABLES.include?(node.type)
-          end
+          emit(s(:and_asgn, *children))
         end
 
       end # OrAsgn

data/lib/mutant/mutator/node/regopt.rb

@@ -7,18 +7,16 @@ module Mutant
       # Regular expression options mutation
       class Regopt < self
 
-        MUTATED_FLAGS = %i[i].freeze
+        MUTATED_FLAGS = %i[i m].freeze
 
         handle(:regopt)
 
       private
 
         def dispatch
-          emit_type(*mutated_flags)
-        end
-
-        def mutated_flags
-          (children - MUTATED_FLAGS)
+          MUTATED_FLAGS.each do |flag|
+            emit_type(*(children - [flag]))
+          end
         end
 
       end # Regopt

data/lib/mutant/mutator/node/rescue.rb

@@ -20,6 +20,11 @@ module Mutant
           mutate_body
           mutate_rescue_bodies
           mutate_else_body
+          emit_singletons if standalone?
+        end
+
+        def standalone?
+          parent_type.nil?
         end
 
         def mutate_rescue_bodies
@@ -30,6 +35,28 @@ module Mutant
               emit_concat(resbody.body)
             end
           end
+          emit_rescue_clause_removals
+          emit_handler_promotion
+        end
+
+        def emit_handler_promotion
+          return unless standalone?
+
+          children_indices(RESCUE_INDICES).each do |index|
+            resbody = AST::Meta::Resbody.new(node: children.fetch(index))
+            emit(resbody.body)
+          end
+        end
+
+        def emit_rescue_clause_removals
+          rescue_indices = children_indices(RESCUE_INDICES).to_a
+          return unless rescue_indices.length > 1
+
+          rescue_indices.each do |index|
+            dup_children = children.dup
+            dup_children.delete_at(index)
+            emit_type(*dup_children)
+          end
         end
 
         def emit_concat(child)

data/lib/mutant/mutator/node/send/binary.rb

@@ -10,6 +10,13 @@ module Mutant
 
           children :left, :operator, :right
 
+          # Pairs of operators where swapping produces equivalent mutants
+          # when the right operand is a multiplicative identity (1 or -1).
+          MULTIPLICATION_DIVISION_SWAP = {
+            %i[* /].freeze => true,
+            %i[/ *].freeze => true
+          }.freeze
+
         private
 
           def dispatch
@@ -21,6 +28,44 @@ module Mutant
             emit_not_equality_mutations
           end
 
+          def emit_selector_replacement
+            config
+              .operators
+              .selector_replacements
+              .fetch(operator, EMPTY_ARRAY)
+              .each do |replacement|
+                emit_selector(replacement) unless equivalent_multiplication_division_swap?(replacement)
+              end
+          end
+
+          # Multiplication and division by 1 or -1 are equivalent operations:
+          #   a * 1  == a / 1   (both equal a)
+          #   a * -1 == a / -1  (both equal -a)
+          #
+          # Swapping * <-> / when RIGHT operand is 1 or -1 produces an equivalent
+          # mutant that can never be killed, wasting test resources.
+          #
+          # Note: LEFT operand identity (e.g., 1 * a -> 1 / a) produces different
+          # results (a vs 1/a) and should NOT be skipped.
+          def equivalent_multiplication_division_swap?(replacement)
+            MULTIPLICATION_DIVISION_SWAP.key?([operator, replacement]) && multiplicative_identity?(right)
+          end
+
+          def multiplicative_identity?(node)
+            return false unless %i[int float].include?(node.type)
+
+            value = Mutant::Util.one(node.children)
+
+            case node.type
+            when :int
+              value.equal?(1) || value.equal?(-1)
+            when :float
+              # rubocop:disable Lint/FloatComparison
+              value.equal?(1.0) || value.equal?(-1.0)
+              # rubocop:enable Lint/FloatComparison
+            end
+          end
+
           def emit_not_equality_mutations
             return unless operator.equal?(:'!=')
 

data/lib/mutant/mutator/node/send.rb

@@ -69,15 +69,20 @@ module Mutant
           emit_reduce_to_sum_mutation
           emit_start_end_with_mutations
           emit_predicate_mutations
-          emit_array_mutation
+          emit_type_coercion_mutations
           emit_static_send
           emit_const_get_mutation
-          emit_integer_mutation
           emit_dig_mutation
           emit_double_negation_mutation
           emit_lambda_mutation
         end
 
+        def emit_type_coercion_mutations
+          emit_array_mutation
+          emit_integer_mutation
+          emit_empty_collection_mutation
+        end
+
         def emit_reduce_to_sum_mutation
           return unless selector.equal?(:reduce)
 
@@ -93,8 +98,6 @@ module Mutant
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/MethodLength
         def emit_start_end_with_mutations
           return unless REGEXP_MATCH_METHODS.include?(selector) && arguments.one?
 
@@ -102,6 +105,10 @@ module Mutant
 
           return unless argument.type.equal?(:regexp)
 
+          emit_regexp_to_prefix_suffix(argument)
+        end
+
+        def emit_regexp_to_prefix_suffix(argument)
           string = Regexp.regexp_body(argument) or return
 
           expressions = ::Regexp::Parser.parse(string)
@@ -171,6 +178,17 @@ module Mutant
           emit(s(:send, nil, :lambda)) if meta.proc?
         end
 
+        def emit_empty_collection_mutation
+          case selector
+          when :to_a, :to_ary
+            emit(s(:array))
+          when :to_h, :to_hash
+            emit(s(:hash))
+          when :to_s, :to_str
+            emit(s(:str, ''))
+          end
+        end
+
         def emit_dig_mutation
           return if !selector.equal?(:dig) || arguments.none?
 
@@ -206,11 +224,9 @@ module Mutant
           emit(receiver) if receiver && !left_op_assignment?
         end
 
-        # rubocop:disable Style/HashEachMethods
-        # - its not a hash ;)
         def mutate_arguments
           emit_type(receiver, selector)
-          remaining_children_with_index.each do |_node, index|
+          remaining_children_indices.each do |index|
             mutate_argument_index(index)
             delete_child(index)
           end

data/lib/mutant/mutator/node/super.rb

@@ -6,6 +6,7 @@ module Mutant
 
       # Mutator for super with parentheses
       class Super < self
+        include AST::Nodes
 
         handle(:super)
 
@@ -13,6 +14,7 @@ module Mutant
 
         def dispatch
           emit_singletons
+          emit(N_ZSUPER) unless children.empty?
           children.each_index do |index|
             mutate_child(index)
             delete_child(index)

data/lib/mutant/mutator/node/zsuper.rb

@@ -9,10 +9,27 @@ module Mutant
 
         handle(:zsuper)
 
+        include AST::Nodes
+
+        ARGUMENTS_DESCENDANT = {
+          def:  AST::Structure.for(:def).descendant(:arguments),
+          defs: AST::Structure.for(:defs).descendant(:arguments)
+        }.freeze
+
       private
 
         def dispatch
           emit_singletons
+          emit(N_EMPTY_SUPER) if enclosing_method_has_arguments?
+        end
+
+        def enclosing_method_has_arguments?
+          current = parent
+          while current
+            descendant = ARGUMENTS_DESCENDANT[current.node.type]
+            return !descendant.value(current.node).children.empty? if descendant
+            current = current.parent
+          end
         end
 
       end # ZSuper

data/lib/mutant/mutator/node.rb

@@ -98,21 +98,15 @@ module Mutant
         emit(node) unless AST::Types::NOT_STANDALONE.include?(node.type)
       end
 
-      def emit_singletons
-        emit_nil
-      end
+      def emit_singletons = emit_nil
 
       def emit_nil
         emit(N_NIL) unless left_op_assignment?
       end
 
-      def parent_node
-        parent&.node
-      end
+      def parent_node = parent&.node
 
-      def parent_type
-        parent_node&.type
-      end
+      def parent_type = parent_node&.type
 
       def left_op_assignment?
         AST::Types::OP_ASSIGN.include?(parent_type) && parent.node.children.first.equal?(node)

data/lib/mutant/mutator.rb

@@ -40,9 +40,7 @@ module Mutant
       output << object
     end
 
-    def dup_input
-      input.dup
-    end
+    def dup_input = input.dup
 
   end # Mutator
 end # Mutant