henitai 0.5.3 → 0.6.0

data/lib/henitai/mutant/lexical_target.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Henitai
+  class Mutant
+    # Resolves the object a re-evaluated +def+ must be defined on, and loads
+    # the subject's source file when its namespace is still undefined.
+    class LexicalTarget
+      # Raised when a subject's namespace is still undefined after its source
+      # file was loaded, so there is no class to reopen.
+      class SubjectNotLoadedError < StandardError; end
+
+      def self.resolve(subject, activation)
+        new.resolve(subject, activation)
+      end
+
+      def self.load_target(subject)
+        new.load_target(subject)
+      end
+
+      # The object the re-evaluated +def+ defines its method on, as Ruby
+      # resolves it: the openers are evaluated with +self+ -- or the receiver
+      # of +def Other.name+ -- as their body. The subject's namespace is only
+      # the resolver's static reading of the source, which cannot tell
+      # whether +Other+ inside +module Outer+ is +Outer::Other+ or +::Other+.
+      # The scope, owner and singleton flag come from the activation, so a
+      # replayed recipe does not need the AST. The subject's file is loaded
+      # first when needed (see +ensure_loaded+), so that evaluating the openers
+      # reopens the loaded class instead of creating an empty one.
+      def resolve(subject, activation)
+        scope = activation.lexical_scope
+        ensure_loaded(subject, scope)
+        source = "#{scope.join('; ')}\n#{activation.owner}\n#{Array.new(scope.size, 'end').join('; ')}"
+        owner = TOPLEVEL_BINDING.eval(source, activation.file, activation.line)
+        activation.singleton ? owner.singleton_class : owner
+      end
+
+      def load_target(subject)
+        Object.const_get(subject.namespace)
+      rescue NameError
+        load_source_file(subject)
+        Object.const_get(subject.namespace)
+      end
+
+      private
+
+      # Evaluating the openers must reopen existing constants, never create
+      # them: a missing class would become an empty phantom that swallows the
+      # mutant. The scope is therefore checked without evaluation first. If it
+      # does not resolve, the subject's file is loaded and checked again. If it
+      # still does not resolve, activation fails instead of creating anything.
+      def ensure_loaded(subject, scope)
+        return load_toplevel_source(subject) if scope.empty?
+        return if LexicalScopeCheck.resolves?(scope)
+
+        load_subject_source(subject)
+        return if LexicalScopeCheck.resolves?(scope)
+
+        raise SubjectNotLoadedError,
+              "cannot activate #{subject.expression}: its source did not define #{subject.namespace}"
+      end
+
+      # Without openers no phantom class can be created; the file is loaded
+      # only when the subject's namespace constant is still missing. A file
+      # that fails to load fails the activation instead of crashing the child.
+      def load_toplevel_source(subject)
+        load_target(subject)
+      rescue NameError
+        nil
+      rescue StandardError, ScriptError => e
+        raise SubjectNotLoadedError, "cannot activate #{subject.namespace}: its source failed to load (#{e.message})"
+      end
+
+      def load_subject_source(subject)
+        load_source_file(subject)
+      rescue StandardError, ScriptError => e
+        raise SubjectNotLoadedError, "cannot activate #{subject.namespace}: its source failed to load (#{e.message})"
+      end
+
+      def load_source_file(subject)
+        source_file = subject.source_file || source_file_from_ast(subject)
+        return unless source_file && File.file?(source_file)
+
+        Thread.current[:henitai_filter_const_warnings] = true
+        load(source_file)
+        loaded_feature = File.expand_path(source_file)
+        $LOADED_FEATURES << loaded_feature unless $LOADED_FEATURES.include?(loaded_feature)
+      ensure
+        Thread.current[:henitai_filter_const_warnings] = false
+      end
+
+      def source_file_from_ast(subject)
+        ast_node = subject.ast_node
+        return unless ast_node
+
+        location = ast_node.location
+        return unless location
+
+        expression = location.expression
+        return unless expression
+
+        expression.source_buffer.name
+      end
+    end
+  end
+end

data/lib/henitai/mutant/replacement.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "unparser"
+
+module Henitai
+  class Mutant
+    # Renders the source text spliced in place of a mutant's original node.
+    #
+    # The text replaces only the original node's range, so it must parse as
+    # one expression wherever it lands. An operator expression such as
+    # `a || b` does not: spliced into `a && b && c` it reads as
+    # `a || (b && c)`. Operator expressions are therefore parenthesised;
+    # parentheses never change an expression's meaning, missing ones can. An
+    # unmutated control keeps the original text.
+    class Replacement
+      OPERATOR_METHODS = %i[
+        + - * / % ** == != < > <= >= <=> === =~ !~ << >> & | ^ ! ~ -@ +@
+      ].freeze
+
+      def self.render(mutant, original_range)
+        new(mutant, original_range).render
+      end
+
+      def initialize(mutant, original_range)
+        @mutant = mutant
+        @original_range = original_range
+      end
+
+      def render
+        return @original_range.source if @mutant.mutated_node.equal?(@mutant.original_node)
+
+        text = unparse(@mutant.mutated_node)
+        operator_expression?(@mutant.mutated_node) ? "(#{text})" : text
+      end
+
+      private
+
+      def unparse(node)
+        Unparser.unparse(node)
+      rescue StandardError => e
+        raise Unparser::UnsupportedNodeError, e.message
+      end
+
+      def operator_expression?(node)
+        return false unless node.is_a?(Parser::AST::Node)
+        return true if %i[and or].include?(node.type)
+
+        %i[send csend].include?(node.type) && OPERATOR_METHODS.include?(node.children[1])
+      end
+    end
+  end
+end

data/lib/henitai/mutant.rb

@@ -21,6 +21,11 @@ module Henitai
 
     autoload :Activator, "henitai/mutant/activator"
     autoload :ParameterSource, "henitai/mutant/parameter_source"
+    autoload :Activation, "henitai/mutant/activation"
+    autoload :LexicalScopeCheck, "henitai/mutant/lexical_scope_check"
+    autoload :LexicalTarget, "henitai/mutant/lexical_target"
+    autoload :DefInjection, "henitai/mutant/def_injection"
+    autoload :Replacement, "henitai/mutant/replacement"
 
     # Status-Vokabular folgt dem Stryker mutation-testing-report-schema.
     # :equivalent ist ein Henitai-interner Status (wird im JSON als "Ignored" serialisiert,
@@ -40,9 +45,12 @@ module Henitai
 
     attr_reader :id, :subject, :operator, :original_node, :mutated_node,
                 :mutation_type, :description, :location,
-                :precomputed_stable_id, :precomputed_activation_source
+                :precomputed_stable_id, :precomputed_activation, :precomputed_replacement
     attr_accessor :status, :killing_test, :duration, :covered_by, :tests_completed,
-                  :ignore_reason, :from_cache
+                  :ignore_reason, :status_reason, :from_cache
+    # Set by MutantGenerator only for mutants whose identity would otherwise
+    # collide with another one (see MutantIdentity).
+    attr_accessor :identity_discriminator
 
     # @param subject [Subject] the subject being mutated
     # @param operator [Symbol] operator name, e.g. :ArithmeticOperator
@@ -51,7 +59,8 @@ module Henitai
     # @param location [Hash] { file:, start_line:, end_line:, start_col:, end_col: }
     # rubocop:disable Metrics/ParameterLists
     def initialize(subject:, operator:, nodes:, description:, location:,
-                   precomputed_stable_id: nil, precomputed_activation_source: nil)
+                   precomputed_stable_id: nil, precomputed_activation: nil,
+                   precomputed_replacement: nil)
       @id            = SecureRandom.uuid
       @subject       = subject
       @operator      = operator
@@ -60,10 +69,9 @@ module Henitai
       @description   = description
       @location      = location
       @precomputed_stable_id = precomputed_stable_id
-      @precomputed_activation_source = precomputed_activation_source
-      @status = :pending
-      @killing_test = @duration = @covered_by = @tests_completed = @ignore_reason = nil
-      @from_cache = false
+      @precomputed_activation = precomputed_activation
+      @precomputed_replacement = precomputed_replacement
+      reset_outcome
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -73,7 +81,9 @@ module Henitai
 
     # Unparsing is expensive and the value is needed by both the JSON and
     # the terminal reporter — compute once per mutant.
-    def mutated_source = @mutated_source ||= safe_unparse(mutated_node)
+    def mutated_source
+      @mutated_source ||= @precomputed_replacement || safe_unparse(mutated_node)
+    end
 
     def killed?      = @status == :killed
     def from_cache?  = @from_cache == true
@@ -85,5 +95,14 @@ module Henitai
     def to_s
       "#{operator}@#{location[:file]}:#{location[:start_line]} — #{description}"
     end
+
+    private
+
+    def reset_outcome
+      @status = :pending
+      @killing_test = @duration = @covered_by = @tests_completed = nil
+      @ignore_reason = @status_reason = nil
+      @from_cache = false
+    end
   end
 end

data/lib/henitai/mutant_generator.rb

@@ -6,7 +6,7 @@ require_relative "source_parser"
 module Henitai
   # Traverses a subject's AST and asks operators to build mutants.
   class MutantGenerator
-    def generate(subjects, operators, config: nil)
+    def generate(subjects, operators, config: nil, sample: true)
       normalized_operators = normalize_operators(operators)
       arid_node_filter = AridNodeFilter.new
       syntax_validator = SyntaxValidator.new
@@ -22,7 +22,12 @@ module Henitai
         )
       end
 
-      sample_mutants(mutants, config:, sampling_strategy:)
+      # Deduplicate programs before sampling: unsampled generation (survivor reruns) must keep the same
+      # representative of a duplicate program as a sampled run, or a reported survivor's stable id would
+      # not be found again. Sampling is stratified by operator within each subject, using a seeded
+      # per-mutant order, and returns kept mutants in input order.
+      unique = distinct_programs(distinct_identities(mutants))
+      sample ? sample_mutants(unique, config:, sampling_strategy:) : unique
     end
 
     private
@@ -71,14 +76,12 @@ module Henitai
       def walk(node, parent: nil)
         return unless node.is_a?(Parser::AST::Node)
 
-        # Str children of a non-heredoc dstr are raw text segments embedded
-        # inside a quoted interpolated string. They have no surrounding quotes
-        # in the source, so replacing them via source-fragment substitution
-        # would insert a quoted literal into the raw-text position and produce
-        # a SyntaxError when the mutant is activated.
-        # Heredoc dstr children are exempt: the heredoc body is plain text, so
-        # inserting "" there stays valid Ruby.
-        return if embedded_non_heredoc_dstr_str?(node, parent)
+        # A str node inside an interpolated string, heredoc, symbol, command,
+        # regexp or word array is raw text without quotes of its own.
+        # Replacing it would insert a quoted literal into the text -- a
+        # different mutation than reported, or a SyntaxError -- so it is not
+        # a StringLiteral site; its container is mutated instead.
+        return if raw_text_segment?(node, parent) || shorthand_value?(node, parent)
 
         apply_operators(node) if node_within_subject_range?(node)
         node.children.each do |child|
@@ -86,18 +89,29 @@ module Henitai
         end
       end
 
-      def embedded_non_heredoc_dstr_str?(node, parent)
-        node.type == :str &&
-          parent&.type == :dstr &&
-          !heredoc_node?(parent)
+      RAW_TEXT_CONTAINERS = %i[dstr dsym xstr regexp].freeze
+      private_constant :RAW_TEXT_CONTAINERS
+
+      def raw_text_segment?(node, parent)
+        return false unless node.type == :str && parent
+
+        RAW_TEXT_CONTAINERS.include?(parent.type) || word_array?(parent)
       end
 
-      def heredoc_node?(node)
-        node.location.respond_to?(:heredoc_body) && node.location.heredoc_body
+      # The value of +build(config:)+ is an implicit call that shares its
+      # source range with the key; replacing it would rewrite the key.
+      def shorthand_value?(node, parent)
+        return false unless parent&.type == :pair && node.equal?(parent.children[1])
+
+        node.location.expression == parent.children[0].location.expression
+      end
+
+      def word_array?(node)
+        node.type == :array && node.location.begin&.source.to_s.start_with?("%")
       end
 
       def apply_operators(node)
-        return if @arid_node_filter.suppressed?(node, @config)
+        return if @arid_node_filter.suppressed?(node)
 
         @operators_by_node_type[node.type].each do |operator|
           operator.mutate(node, subject: @subject).each do |mutant|
@@ -132,6 +146,35 @@ module Henitai
       end
     end
 
+    # Mutants sharing an identity are told apart by where their original node
+    # ends; those that also end at the same place are the same mutation
+    # twice, and only the first is kept.
+    def distinct_identities(mutants)
+      mutants.group_by { |mutant| MutantIdentity.stable_id(mutant) }.each_value do |group|
+        group.each { |mutant| mutant.identity_discriminator = node_end(mutant) } if group.size > 1
+      end
+      mutants.uniq { |mutant| MutantIdentity.stable_id(mutant) }
+    end
+
+    # Different operators can produce the same program -- BooleanLiteral's
+    # `return false` for `return true if x` is also ReturnValue's. Running it
+    # twice would count one result twice; the first mutant is kept. Mutants
+    # without a computable activation are left to the later checks.
+    def distinct_programs(mutants)
+      seen = {}
+      mutants.select do |mutant|
+        program = Mutant::Activator.activation_source_for(mutant)
+        key = [mutant.subject, program]
+        program.nil? || (!seen.key?(key) && (seen[key] = true))
+      end
+    end
+
+    def node_end(mutant)
+      range = mutant.original_node&.location&.expression
+      start = mutant.subject.source_range&.begin
+      range && start ? "#{range.last_line - start}:#{range.last_column}" : range&.end_pos.to_s
+    end
+
     def sample_mutants(mutants, config:, sampling_strategy:)
       sampling = config&.sampling
       return mutants unless sampling
@@ -140,7 +183,8 @@ module Henitai
       sampling_strategy.sample(
         mutants,
         ratio: sampling[:ratio],
-        strategy: sampling[:strategy] || :stratified
+        strategy: sampling[:strategy] || :stratified,
+        seed: sampling[:seed] || SamplingStrategy::DEFAULT_SEED
       )
     end
 

data/lib/henitai/mutant_history_store/verdict_cache.rb

@@ -29,7 +29,7 @@ module Henitai
       def killed_cache_bindings(mutant)
         [
           VerdictFingerprint.subject_source_hash(mutant),
-          VerdictFingerprint.tests_fingerprint(covered_tests_for(mutant))
+          VerdictFingerprint.tests_fingerprint(covered_tests_for(mutant), context_sha: reuse_context&.fingerprint)
         ]
       end
 
@@ -38,34 +38,35 @@ module Henitai
       # which reflects selector fallback and test_excludes and would
       # permanently mismatch the live set. When the fingerprint cannot be
       # recomputed (no per-test map, recipe stubs without a source range),
-      # the previously stored bindings are kept: the filter re-validates
-      # everything live before reuse, so a carried-forward fingerprint can
-      # never validate a changed state.
+      # the previously stored bindings are kept, but only from a survived
+      # row of the same subject source: a killed row's or an edited method's
+      # fingerprints would vouch for a state this survivor never ran in.
       def survived_cache_bindings(mutant, existing_row)
         bindings = [
           VerdictFingerprint.subject_source_hash(mutant),
           survived_tests_fingerprint(mutant)
         ]
         return bindings unless bindings.any?(&:nil?)
+        return [nil, nil] unless carry_survived_bindings?(bindings.first, existing_row)
 
         existing_cache_bindings(existing_row)
       end
 
+      def carry_survived_bindings?(source_hash, existing_row)
+        return false unless existing_row && existing_row["current_status"] == "survived"
+
+        source_hash.nil? || source_hash == existing_row["subject_source_hash"]
+      end
+
       def survived_tests_fingerprint(mutant)
         return nil unless per_test_coverage
 
         VerdictFingerprint.survivor_tests_fingerprint(
           per_test_coverage.tests_covering(mutant),
-          dependency_sha: recording_dependency_sha
+          context_sha: reuse_context&.fingerprint
         )
       end
 
-      # One dependency sha per record call set, computed lazily so runs
-      # without survivors never touch the dependency files.
-      def recording_dependency_sha
-        @recording_dependency_sha ||= VerdictFingerprint.dependency_fingerprint
-      end
-
       def existing_cache_bindings(existing_row)
         return [nil, nil] unless existing_row
 

data/lib/henitai/mutant_history_store.rb

@@ -17,9 +17,12 @@ module Henitai
     # @param per_test_coverage [PerTestCoverage, nil] live per-test coverage
     #   view used to record the full-map intersection set for survived
     #   verdicts; without it survived rows stay NULL (never reusable).
-    def initialize(path:, per_test_coverage: nil)
+    # @param reuse_context [ReuseContext, nil] fingerprint recorded with every
+    #   cached verdict; without it no verdict is cached (never reusable).
+    def initialize(path:, per_test_coverage: nil, reuse_context: nil)
       @path = path
       @per_test_coverage = per_test_coverage
+      @reuse_context = reuse_context
     end
 
     attr_reader :path
@@ -30,7 +33,7 @@ module Henitai
       with_database do |db|
         ensure_schema(db)
         db.transaction do
-          insert_run(db, result, version, recorded_at) unless partial_rerun?(result)
+          insert_run(db, result, version, recorded_at) if full_run?(result)
           Array(result.mutants).each do |mutant|
             upsert_mutant(db, mutant, version, recorded_at)
           end
@@ -72,7 +75,7 @@ module Henitai
 
     private
 
-    attr_reader :per_test_coverage
+    attr_reader :per_test_coverage, :reuse_context
 
     def verdict_from_row(row)
       return nil unless row && VerdictCache::CACHEABLE_STATUSES.include?(row["current_status"])
@@ -85,6 +88,11 @@ module Henitai
       }
     end
 
+    def full_run?(result)
+      authoritative = !result.respond_to?(:authoritative?) || result.authoritative?
+      authoritative && !partial_rerun?(result)
+    end
+
     def partial_rerun?(result)
       result.respond_to?(:partial_rerun?) && result.partial_rerun?
     end
@@ -133,8 +141,10 @@ module Henitai
       end
     end
 
+    # Recipe stubs carry a precomputed id that cannot be recomputed from
+    # their (absent) AST nodes.
     def stable_mutant_id(mutant)
-      MutantIdentity.stable_id(mutant)
+      mutant.respond_to?(:stable_id) ? mutant.stable_id : MutantIdentity.stable_id(mutant)
     end
 
     def mutation_history_entry(mutant, version, recorded_at)

data/lib/henitai/mutant_identity.rb

@@ -19,8 +19,12 @@ module Henitai
       digest(legacy_identity_components(mutant))
     end
 
+    # The discriminator is present only for mutants that would otherwise
+    # share an identity -- nested nodes starting at the same position, such
+    # as the calls of `x.a.b.c` -- so every other identity stays unchanged.
     def self.identity_components(mutant)
-      legacy_identity_components(mutant) + [site_offset(mutant)]
+      discriminator = mutant.respond_to?(:identity_discriminator) && mutant.identity_discriminator
+      legacy_identity_components(mutant) + [site_offset(mutant)] + [discriminator].compact
     end
     private_class_method :identity_components
 

data/lib/henitai/mutant_verdict.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Classifies one mutant run from the child's own report and the way the
+  # child process ended.
+  #
+  # The child reports what it got to: a failed activation, a finished test run
+  # with the exit code the tests returned, or a SystemExit raised while the
+  # tests ran. Only a finished test run yields a test verdict (Killed or
+  # Survived); everything else is a harness or runtime status that stays out of
+  # the detected count. In particular a child that died without a report, or
+  # was killed by a signal, is a RuntimeError, never a kill.
+  class MutantVerdict
+    def initialize(wait_result:, report:, stdout:, stderr:)
+      @wait_result = wait_result
+      @report = report
+      @output = "#{stdout}\n#{stderr}"
+    end
+
+    # @return [Array(Symbol, String|nil)] status and reason
+    def to_a
+      return [:timeout, nil] if @wait_result == :timeout
+      return [:runtime_error, "child terminated by signal #{signal_name}"] if signaled?
+      return [:runtime_error, "child exited with status #{exit_status} without reporting a result"] unless @report
+
+      reported_verdict
+    end
+
+    # @return [Array<String>] expanded paths of the test files that failed
+    #   in the child, or an empty list when the child did not report them or
+    #   also saw a failure it could not attribute to a file (which makes the
+    #   kill genuine, never one a flaky file alone may have caused)
+    def killing_tests
+      return [] if @report.nil? || @report["unattributed_failures"]
+
+      Array(@report["failed_tests"]).map { |path| File.expand_path(path) }
+    end
+
+    private
+
+    def reported_verdict
+      case @report["outcome"]
+      when "activation_failed" then [:compile_error, "activation failed: #{@report['reason']}"]
+      when "environment_failed"
+        [:compile_error, "the test files failed to load, before the mutant was activated"]
+      when "system_exit"
+        [:runtime_error, "the test run ended early with SystemExit (status #{@report['status']})"]
+      when "tests_finished" then test_verdict
+      else [:runtime_error, "child reported an unknown outcome: #{@report['outcome']}"]
+      end
+    end
+
+    def test_verdict
+      return [:compile_error, "no examples ran"] if ExampleSummary.none_ran?(@output)
+
+      @report["exit_code"].to_i.zero? ? [:survived, nil] : [:killed, nil]
+    end
+
+    def signaled?
+      @wait_result.respond_to?(:signaled?) && @wait_result.signaled?
+    end
+
+    def signal_name
+      "SIG#{Signal.signame(@wait_result.termsig)}"
+    end
+
+    def exit_status
+      @wait_result.respond_to?(:exitstatus) ? @wait_result.exitstatus : "unknown"
+    end
+  end
+end

data/lib/henitai/operators/array_declaration.rb

@@ -12,7 +12,11 @@ module Henitai
         NODE_TYPES
       end
 
+      # A list without brackets (rescue classes, multiple return values,
+      # multiple assignment) is not an array literal and has no empty form.
       def mutate(node, subject:)
+        return [] unless node.location.begin
+
         if node.children.empty?
           [empty_array_mutant(subject:, node:)]
         else

data/lib/henitai/operators/assignment_expression.rb

@@ -51,6 +51,8 @@ module Henitai
         when :casgn
           namespace, name = left.children
           Parser::AST::Node.new(:casgn, [namespace, name, right])
+        when :indexasgn
+          left.updated(nil, [*left.children, right])
         when :send
           assignment_name = left.children[1] == :[] ? :[]= : :"#{left.children[1]}="
           receiver, _method_name, *arguments = left.children

data/lib/henitai/operators/conditional_expression.rb

@@ -28,6 +28,8 @@ module Henitai
       private
 
       def mutate_if(node, subject:)
+        return elsif_condition_mutants(node, subject:) if elsif?(node)
+
         condition, then_branch, else_branch = node.children
         mutations = condition_variants(node, subject:, condition:)
 
@@ -38,6 +40,22 @@ module Henitai
         mutations
       end
 
+      # An elsif's source range starts at `elsif` and has no `end`, so a
+      # re-rendered `if ... end` cannot take its place. Only its condition is
+      # mutated, in place; removing a branch is what "replaced condition with
+      # false" already does.
+      def elsif_condition_mutants(node, subject:)
+        condition = node.children.first
+        [[true_node, "replaced condition with true"], [false_node, "replaced condition with false"],
+         [negate(condition), "negated condition"]].map do |replacement, description|
+          build_mutant(subject:, original_node: condition, mutated_node: replacement, description:)
+        end
+      end
+
+      def elsif?(node)
+        node.location.respond_to?(:keyword) && node.location.keyword&.source == "elsif"
+      end
+
       def mutate_case(node, subject:)
         condition = node.children.first
         when_nodes, else_branch = case_children(node.children.drop(1))
@@ -154,8 +172,10 @@ module Henitai
         Parser::AST::Node.new(node.type, children)
       end
 
+      # The parentheses are part of the mutation: `!a > b` would negate only
+      # `a` and compare the boolean, which is not the reported mutant.
       def negate(node)
-        Parser::AST::Node.new(:send, [node, :!])
+        Parser::AST::Node.new(:send, [Parser::AST::Node.new(:begin, [node]), :!])
       end
 
       # rubocop:disable Lint/BooleanSymbol

data/lib/henitai/operators/hash_literal.rb

@@ -9,7 +9,10 @@ module Henitai
     # set) because framework key normalization makes it frequently unkillable
     # (ADR-12).
     class HashLiteral < Henitai::Operator
-      NODE_TYPES = [:hash].freeze
+      # Keyword arguments (kwargs) are mutated like hash literals; the mutant
+      # keeps the node type, so a removed keyword never turns the remaining
+      # ones into a positional hash.
+      NODE_TYPES = %i[hash kwargs].freeze
 
       def self.node_types
         NODE_TYPES
@@ -29,8 +32,8 @@ module Henitai
         build_mutant(
           subject:,
           original_node: node,
-          mutated_node: Parser::AST::Node.new(:hash, []),
-          description: "replaced hash with empty hash"
+          mutated_node: node.updated(nil, []),
+          description: node.type == :kwargs ? "removed keyword arguments" : "replaced hash with empty hash"
         )
       end
 
@@ -52,7 +55,7 @@ module Henitai
 
       def hash_without_pair(node, pair_index)
         remaining = node.children.reject.with_index { |_pair, index| index == pair_index }
-        Parser::AST::Node.new(:hash, remaining)
+        node.updated(nil, remaining)
       end
 
       # Pair keys are always AST nodes (sym/str/…); their first child is the