henitai 0.5.3 → 0.6.0

data/lib/henitai/slot_scheduler/process_control.rb

@@ -8,6 +8,9 @@ module Henitai
     # scheduler remains the single caller of the process table. Mixed into
     # {SlotScheduler}; relies on its +runtime+ reader.
     module ProcessControl
+      GROUP_POLL_INTERVAL = 0.02
+      GROUP_POLL_COUNT = 10
+
       private
 
       def monotonic_time
@@ -33,6 +36,36 @@ module Henitai
         end
       end
 
+      # Terminates whatever a finished child left behind in its process group
+      # (daemons, grandchildren). Waits at most PROCESS_DRAIN_WINDOW for them to
+      # exit on SIGTERM before escalating to SIGKILL.
+      def tear_down_process_group(pid)
+        signal_process_group(pid, :SIGTERM)
+        return unless group_members_remain?(pid)
+
+        signal_process_group(pid, :SIGKILL)
+      end
+
+      def group_members_remain?(pid)
+        GROUP_POLL_COUNT.times do
+          return false unless process_group_alive?(pid)
+
+          runtime.pause(GROUP_POLL_INTERVAL)
+        end
+        process_group_alive?(pid)
+      end
+
+      # Signal 0 probes existence only. ESRCH means the group is empty; EPERM
+      # means members exist but belong to someone else.
+      def process_group_alive?(pid)
+        runtime.kill(0, -pid)
+        true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
+      end
+
       def reap_pid(pid)
         runtime.wait(pid)
       rescue Errno::ECHILD, Errno::ESRCH

data/lib/henitai/slot_scheduler/retry_policy.rb

@@ -4,17 +4,19 @@ module Henitai
   class SlotScheduler
     # Decides whether a finished slot earns another attempt.
     #
-    # A survived verdict is the only retryable one: it is the verdict a flaky
-    # test can fake, whereas a kill cannot be faked by flakiness. A requested
-    # shutdown vetoes retries outright — respawning children while tearing the
-    # run down would leak processes past the drain window.
+    # The rule itself lives in FlakyRetryDecision; this class adds the shutdown
+    # veto. A requested shutdown vetoes retries outright — respawning children
+    # while tearing the run down would leak processes past the drain window.
     class RetryPolicy
-      def initialize(max_retries:)
+      def initialize(max_retries:, flaky_tests: FlakyTestRegistry.new([]))
         @max_retries = max_retries.to_i
+        @decision = FlakyRetryDecision.new(flaky_tests: flaky_tests, max_retries: @max_retries)
       end
 
       def retry?(slot:, result:, shutdown:)
-        !shutdown && result.survived? && slot.retry_count < @max_retries
+        return false if shutdown || result.status != :killed
+
+        @decision.retry?(status: :killed, killing_tests: result.killing_tests, attempts: slot.retry_count)
       end
     end
   end

data/lib/henitai/slot_scheduler.rb

@@ -51,7 +51,8 @@ module Henitai
     # rubocop:disable Metrics/ParameterLists -- every one of these is a distinct
     # collaborator supplied by ProcessWorkerRunner; bundling them into a context
     # object would only move the list.
-    def initialize(integration:, config:, progress_reporter:, options:, host:, slot_table: SlotTable.new)
+    def initialize(integration:, config:, progress_reporter:, options:, host:, slot_table: SlotTable.new,
+                   flaky_tests: nil)
       # rubocop:enable Metrics/ParameterLists
       @integration = integration
       @config = config
@@ -59,6 +60,7 @@ module Henitai
       @options = options
       @host = host
       @slot_table = slot_table
+      @injected_flaky_tests = flaky_tests
       @pending = []
       @results = []
       @flaky_retry_count = 0
@@ -119,7 +121,7 @@ module Henitai
       worker_index = slot_table.next_free_worker_index(worker_count)
       with_worker_slot(worker_index) do
         handle = integration.spawn_mutant(mutant: mutant, test_files: test_files)
-        register_slot(handle, mutant, worker_index, slot_timeout(mutant, test_files))
+        register_slot(handle, mutant, worker_index, handle.timeout || slot_timeout(mutant, test_files))
       end
     rescue StandardError => e
       record_spawn_failure(mutant, e)
@@ -154,14 +156,21 @@ module Henitai
       resolver ? resolver.call(mutant, test_files) : config.timeout
     end
 
+    # Every path that reaps a mutant child ends here, so this is the single
+    # place that tears down the child's process group. A reaped pid that owns
+    # no slot (wait2(-1) can reap any helper child) is never signalled.
     def complete_slot(pid, wait_result)
       slot_id = slot_table.release_pid(pid)
       return unless slot_id
 
+      tear_down_process_group(pid)
+
       slot = slot_table.fetch(slot_id)
       return unless slot
 
       Integration::SchedulerDiagnostics.child_ended(pid)
+      return rerun_lost_slot(slot) if lost?(wait_result)
+
       result = integration.build_result(wait_result, slot.log_paths)
       dispatch_slot_result(slot, result)
     end
@@ -175,6 +184,7 @@ module Henitai
     def finalize_slot(slot, result)
       slot_table.delete(slot.slot_id)
       slot.mutant.status = result.status
+      ScenarioExecutionResult.copy_reason(result, slot.mutant)
       results << result
       progress_reporter&.progress(slot.mutant, scenario_result: result)
       result.release_output! if result.respond_to?(:release_output!)
@@ -184,7 +194,13 @@ module Henitai
     # the runner builds when nothing is pending) pass `config: nil`, and this
     # is only reached once a slot has actually finished.
     def retry_policy
-      @retry_policy ||= RetryPolicy.new(max_retries: config.max_flaky_retries)
+      @retry_policy ||= RetryPolicy.new(max_retries: config.max_flaky_retries, flaky_tests: flaky_tests)
+    end
+
+    def flaky_tests
+      return @injected_flaky_tests if @injected_flaky_tests
+
+      FlakyTestRegistry.for_config(config)
     end
 
     def drain_verdict
@@ -199,20 +215,43 @@ module Henitai
       @test_file_selection ||= TestFileSelection.new(options: options, integration: integration)
     end
 
+    # The fork server died while the mutant ran, so nothing is known about
+    # it. It is run again on the local path and never becomes a verdict.
+    def lost?(wait_result)
+      wait_result.respond_to?(:lost?) && wait_result.lost?
+    end
+
+    def rerun_lost_slot(slot)
+      return slot_table.delete(slot.slot_id) if shutdown?
+
+      respawn_slot(slot) { |handle| restart_slot(slot, handle) }
+    end
+
     def retry_slot(slot)
-      test_files = test_file_selection.for(slot.mutant)
-      with_worker_slot(slot.worker_index) do
-        handle = integration.spawn_mutant(mutant: slot.mutant, test_files: test_files)
-        finish_retry(slot, handle)
-      end
+      respawn_slot(slot) { |handle| finish_retry(slot, handle) }
+    end
+
+    def respawn_slot(slot)
+      with_worker_slot(slot.worker_index) { yield respawn_handle(slot) }
     rescue StandardError => e
       slot_table.delete(slot.slot_id)
       record_spawn_failure(slot.mutant, e)
     end
 
+    def respawn_handle(slot)
+      test_files = test_file_selection.for(slot.mutant)
+      handle = integration.spawn_mutant(mutant: slot.mutant, test_files: test_files)
+      slot.timeout = handle.timeout || slot_timeout(slot.mutant, test_files)
+      handle
+    end
+
     def finish_retry(slot, handle)
       @flaky_retry_count += 1 if slot.retry_count.zero?
       slot.retry_count += 1
+      restart_slot(slot, handle)
+    end
+
+    def restart_slot(slot, handle)
       reset_slot_for_retry(slot, handle)
       slot_table.register_pid(handle.pid, slot.slot_id)
       Integration::SchedulerDiagnostics.child_started(handle.pid)

data/lib/henitai/source_file_selection.rb

@@ -58,7 +58,7 @@ module Henitai
     # dirty and untracked files): the working tree is what gets tested, so it is
     # always part of "changed since REF".
     def changed_paths_since
-      @git_diff_analyzer.changed_files(from: @since, to: "HEAD") +
+      @git_diff_analyzer.changed_files_since(@since) +
         @git_diff_analyzer.working_tree_changed_files
     end
 

data/lib/henitai/source_parser.rb

@@ -12,10 +12,18 @@ module Henitai
   class SourceParser
     DEFAULT_PATH = "(string)"
 
+    # Emits the modern parser-gem AST format (procarg0, kwargs, index, lambda,
+    # forward_arg, ...). The legacy format cannot tell `|x|` from `|x,|` or
+    # keyword arguments from a braced hash, so re-rendering a mutated subtree
+    # through the unparser would silently change its meaning.
+    class Builder < Prism::Translation::Parser::Builder
+      modernize
+    end
+
     @cache = {}
 
-    def self.parse(source, path: DEFAULT_PATH)
-      new.parse(source, path:)
+    def self.parse(source, path: DEFAULT_PATH, line: 1)
+      new.parse(source, path:, line:)
     end
 
     # Returns the parsed AST for +path+, re-using a cached result when the
@@ -31,20 +39,32 @@ module Henitai
       @cache.clear
     end
 
-    def parse(source, path: DEFAULT_PATH)
-      Prism::Translation::ParserCurrent.new.parse(source_buffer(source, path))
+    # Reads +path+ as UTF-8 source, honouring a magic encoding comment the
+    # same way parsing does. Raises EncodingError when the bytes are invalid
+    # in the declared (or default UTF-8) encoding.
+    def self.read_file(path)
+      buffer = Parser::Source::Buffer.new(path)
+      buffer.source = File.read(path, encoding: Encoding::UTF_8)
+      buffer.source
+    end
+
+    # +line+ is the number of the source's first line, as for Kernel#eval.
+    def parse(source, path: DEFAULT_PATH, line: 1)
+      Prism::Translation::ParserCurrent.new(Builder.new).parse(source_buffer(source, path, line))
     end
 
+    # Read as UTF-8, Ruby's own default source encoding, not the process
+    # locale: with LANG=C the default external encoding is US-ASCII and every
+    # non-ASCII source file would fail to parse. A magic encoding comment is
+    # still honoured by the parser buffer, which re-encodes to UTF-8.
     def parse_file(path)
-      # Ruby's file encoding rules apply here. Projects that use explicit source
-      # encoding comments can be handled by a future encoding-aware option.
-      parse(File.read(path), path:)
+      parse(File.read(path, encoding: Encoding::UTF_8), path:)
     end
 
     private
 
-    def source_buffer(source, path)
-      Parser::Source::Buffer.new(path).tap do |buffer|
+    def source_buffer(source, path, line = 1)
+      Parser::Source::Buffer.new(path, line).tap do |buffer|
         buffer.source = source
       end
     end

data/lib/henitai/static_filter.rb

@@ -10,9 +10,11 @@ module Henitai
     DEFAULT_PER_TEST_COVERAGE_REPORT_PATH = CoverageReportReader::DEFAULT_PER_TEST_COVERAGE_REPORT_PATH
 
     def initialize(coverage_report_reader: CoverageReportReader.new,
-                   skip_directives: MutationSkipDirectives.new)
+                   skip_directives: MutationSkipDirectives.new,
+                   fidelity_check: FidelityCheck.new)
       @coverage_report_reader = coverage_report_reader
       @skip_directives = skip_directives
+      @fidelity_check = fidelity_check
     end
 
     # This method is the gate-level filter orchestrator.
@@ -22,6 +24,7 @@ module Henitai
 
       Array(mutants).each do |mutant|
         next if ignored_mutant?(mutant, config) || skip_directive_mutant?(mutant)
+        next if unfaithful_mutant?(mutant)
 
         mark_equivalent_mutant(mutant)
         mark_no_coverage_mutant(
@@ -64,21 +67,22 @@ module Henitai
 
     private
 
-    attr_reader :coverage_report_reader, :skip_directives
+    attr_reader :coverage_report_reader, :skip_directives, :fidelity_check
 
-    def ignored?(mutant, config)
-      source = source_for(mutant)
-      return false unless source
+    def ignore_pattern_for(mutant, config)
+      patterns = compiled_ignore_patterns(config)
+      return if patterns.empty?
 
-      compiled_ignore_patterns(config).any? do |pattern|
-        pattern.match?(source)
-      end
+      line = source_line_for(mutant)
+      patterns.find { |pattern| pattern.match?(line) }
     end
 
     def ignored_mutant?(mutant, config)
-      return false unless ignored?(mutant, config)
+      pattern = ignore_pattern_for(mutant, config)
+      return false unless pattern
 
       mutant.status = :ignored
+      mutant.ignore_reason = "ignore_patterns: #{pattern.source}" if mutant.respond_to?(:ignore_reason=)
       true
     end
 
@@ -91,6 +95,17 @@ module Henitai
       true
     end
 
+    # A mutant whose activated code is not the reported mutation must not
+    # run: any test failure would be credited to a change it never made.
+    def unfaithful_mutant?(mutant)
+      reason = fidelity_check.violation(mutant)
+      return false unless reason
+
+      mutant.status = :compile_error
+      mutant.status_reason = reason
+      true
+    end
+
     def mark_equivalent_mutant(mutant)
       return unless mutant.pending?
 
@@ -111,11 +126,27 @@ module Henitai
       covered.any? { |line| (mutant.location[:start_line]..mutant.location[:end_line]).cover?(line) }
     end
 
-    def source_for(mutant)
-      original_node = mutant.original_node
-      location = original_node&.location
-      expression = location&.expression
-      expression&.source
+    # Ignore patterns are line-scoped: they match the source line on which the
+    # mutant's original node starts, like a trailing `# henitai:disable`.
+    def source_line_for(mutant)
+      line_number = mutant.location[:start_line]
+      return unless line_number.is_a?(Integer) && line_number.positive?
+
+      lines = source_lines_for(mutant.location[:file])
+      lines&.fetch(line_number - 1, nil)
+    end
+
+    def source_lines_for(path)
+      @source_lines ||= {}
+      return @source_lines[path] if @source_lines.key?(path)
+
+      @source_lines[path] = read_source_lines(path)
+    end
+
+    def read_source_lines(path)
+      SourceParser.read_file(path).lines
+    rescue SystemCallError, IOError, EncodingError
+      nil
     end
 
     def compiled_ignore_patterns(config)

data/lib/henitai/stillborn_filter.rb

@@ -1,11 +1,81 @@
 # frozen_string_literal: true
 
+require "prism"
 require "unparser"
 
 module Henitai
   # Suppresses mutants that do not produce syntactically valid Ruby.
+  #
+  # A mutant of a resolved method is checked in context: its activation
+  # source -- the whole method with the mutation spliced in -- must parse. A
+  # fragment such as `size: 2` (one keyword argument left) or a `next` guard
+  # is only valid inside its call or block, so checking it on its own would
+  # drop valid mutants. Without a method to splice into, the rendered
+  # fragment is compiled inside a bare method instead.
+  #
+  # A mutant that removes the only assignment of a local which is read later
+  # is suppressed as well (ACT-10): Ruby then parses the later read as a
+  # method call, so the mutant would fail with a NameError wherever it runs
+  # -- a trivial kill of a program other than the reported one.
   class StillbornFilter
+    # Collects the names of identifiers Ruby parses as method calls.
+    class VariableCalls < Prism::Visitor
+      def self.tally(node)
+        new.tap { |visitor| node.accept(visitor) }.names.tally
+      end
+
+      attr_reader :names
+
+      def initialize
+        super
+        @names = []
+      end
+
+      def visit_call_node(node)
+        @names << node.name if node.variable_call?
+        super
+      end
+    end
+
+    def initialize
+      @original_calls = {}.compare_by_identity
+    end
+
     def suppressed?(mutant)
+      activation = in_context_activation(mutant)
+      return fragment_invalid?(mutant) unless activation
+
+      result = Prism.parse(activation.source)
+      result.errors.any? || drops_local?(mutant.subject.ast_node, result.value)
+    end
+
+    private
+
+    def drops_local?(method_node, activated)
+      original = @original_calls[method_node] ||= original_calls(method_node)
+      VariableCalls.tally(activated).any? do |name, count|
+        count > original.fetch(name, 0) && local_read?(method_node, name)
+      end
+    end
+
+    def original_calls(method_node)
+      VariableCalls.tally(Prism.parse(method_node.location.expression.source).value)
+    end
+
+    def local_read?(node, name)
+      return false unless node.is_a?(Parser::AST::Node)
+      return true if node.type == :lvar && node.children.first == name
+
+      node.children.any? { |child| local_read?(child, name) }
+    end
+
+    def in_context_activation(mutant)
+      return unless mutant.subject.respond_to?(:ast_node) && mutant.subject.ast_node
+
+      Mutant::Activator.activation_for(mutant)
+    end
+
+    def fragment_invalid?(mutant)
       source = render(mutant)
       return true unless source
 
@@ -15,8 +85,6 @@ module Henitai
       true
     end
 
-    private
-
     def render(mutant)
       Unparser.unparse(mutant.mutated_node)
     rescue StandardError

data/lib/henitai/subject.rb

@@ -14,7 +14,7 @@ module Henitai
   # descriptions in the test suite.
   class Subject
     attr_reader :namespace, :method_name, :method_type, :source_file,
-                :source_range, :ast_node
+                :source_range, :ast_node, :lexical_scope
 
     # @param expression [String] subject expression, e.g. "Foo::Bar#method"
     def self.parse(expression)
@@ -25,11 +25,15 @@ module Henitai
     # @param method_name [String]  method name (nil for wildcard subjects)
     # @param method_type [Symbol]  :instance or :class
     # @param source_location [Hash] file/range metadata for the subject source
+    # @param lexical_scope [Array<String>, nil] the openers of the modules and
+    #   classes around the method as written ("module Outer", "class Inner",
+    #   "class << self", "Point.class_eval do"); nil when a scope cannot be
+    #   reopened by name
     # The explicit keyword API matches the public call sites and keeps the
     # metadata fields discoverable without a single options hash.
     # rubocop:disable Metrics/ParameterLists
     def initialize(expression: nil, namespace: nil, method_name: nil,
-                   method_type: :instance, source_location: nil, ast_node: nil)
+                   method_type: :instance, source_location: nil, ast_node: nil, lexical_scope: nil)
       if expression
         parse_expression(expression)
       else
@@ -40,6 +44,7 @@ module Henitai
       @source_file  = source_location&.fetch(:file, nil)
       @source_range = source_location&.fetch(:range, nil)
       @ast_node = ast_node
+      @lexical_scope = lexical_scope
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -56,7 +61,7 @@ module Henitai
     private
 
     def parse_expression(expr)
-      if (m = expr.match(/\A(.+?)([#.])(\w+)\z/))
+      if (m = expr.match(/\A([\w:]+)([#.])([^#.\s]+)\z/))
         @namespace   = m[1]
         @method_type = m[2] == "." ? :class : :instance
         @method_name = m[3]

data/lib/henitai/subject_resolver.rb

@@ -2,6 +2,7 @@
 
 require_relative "source_parser"
 require_relative "subject"
+require_relative "constant_path"
 
 module Henitai
   # Resolves AST subjects from Ruby source files.
@@ -26,6 +27,7 @@ module Henitai
     private
 
     def resolve_from_file(path)
+      @scope = []
       subjects = []
       walk(
         SourceParser.parse_file(path),
@@ -38,6 +40,7 @@ module Henitai
 
     def walk(node, namespace:, singleton_context:, subjects:)
       return unless node.respond_to?(:type)
+      return walk_constructor_body(node, namespace, subjects) if constructor_assignment?(node)
       return if anonymous_class_block?(node)
 
       namespace, singleton_context = update_context(
@@ -46,8 +49,60 @@ module Henitai
         singleton_context
       )
 
-      collect_subject(node, namespace, singleton_context, subjects)
-      traverse_children(node, namespace, singleton_context, subjects)
+      within_scope(node) do
+        collect_subject(node, namespace, singleton_context, subjects)
+        traverse_children(node, namespace, singleton_context, subjects)
+      end
+    end
+
+    # +Point = Struct.new(:x) do ... end+: the block is evaluated with
+    # class_eval on the new class, so its methods belong to +Point+ while
+    # constant lookup stays in the enclosing scope. +Point.class_eval do+
+    # reproduces exactly that when the method is re-evaluated.
+    def walk_constructor_body(node, namespace, subjects)
+      @scope.push("#{assigned_constant_source(node)}.class_eval do")
+      walk(node.children[2].children[2], namespace: ConstantPath.qualify(namespace, ConstantPath.of(node)),
+                                         singleton_context: false, subjects:)
+    ensure
+      @scope.pop
+    end
+
+    def constructor_assignment?(node)
+      node.type == :casgn && anonymous_class_block?(node.children[2])
+    end
+
+    def assigned_constant_source(node)
+      node.location.expression.begin.join(node.location.name).source
+    end
+
+    # Tracks the openers of the modules and classes around the walk position,
+    # so a method can later be re-evaluated in its original lexical scope.
+    def within_scope(node)
+      opener = scope_opener(node)
+      @scope.push(opener) unless opener == :none
+      yield
+    ensure
+      @scope.pop unless opener == :none
+    end
+
+    def scope_opener(node)
+      case node.type
+      when :class, :module then "#{node.type} #{node.children.first.location.expression.source}"
+      when :sclass then singleton_opener(node.children.first)
+      else :none
+      end
+    end
+
+    def singleton_opener(receiver)
+      case receiver.type
+      when :self then "class << self"
+      when :const then "class << #{receiver.location.expression.source}"
+      end
+    end
+
+    # nil when some enclosing scope cannot be reopened by name (class << obj).
+    def lexical_scope
+      @scope.include?(nil) ? nil : @scope.dup
     end
 
     def collect_subject(node, namespace, singleton_context, subjects)
@@ -70,7 +125,7 @@ module Henitai
 
       receiver = call_node.children.first
       method_name = call_node.children[1]
-      receiver_name = constant_name(receiver)
+      receiver_name = ConstantPath.of(receiver)&.delete_prefix("::")
 
       anonymous_constructor_call?(receiver_name, method_name)
     end
@@ -86,10 +141,10 @@ module Henitai
     def update_context(node, namespace, singleton_context)
       case node.type
       when :class, :module
-        [qualify_namespace(namespace, constant_name(node.children.first)),
+        [ConstantPath.qualify(namespace, ConstantPath.of(node.children.first)),
          singleton_context]
       when :sclass
-        [namespace, true]
+        [ConstantPath.owner(node.children.first, namespace), true]
       else
         [namespace, singleton_context]
       end
@@ -102,7 +157,7 @@ module Henitai
       when :def
         instance_subject(node, namespace, singleton_context)
       when :defs
-        class_subject(node, namespace)
+        class_subject(node, ConstantPath.owner(node.children.first, namespace))
       end
     end
 
@@ -114,7 +169,8 @@ module Henitai
         method_name: method_name(node.children.first),
         method_type: singleton_context ? :class : :instance,
         source_location: source_location_for(node),
-        ast_node: node
+        ast_node: node,
+        lexical_scope:
       )
     end
 
@@ -126,7 +182,8 @@ module Henitai
         method_name: method_name(node.children[1]),
         method_type: :class,
         source_location: source_location_for(node),
-        ast_node: node
+        ast_node: node,
+        lexical_scope:
       )
     end
 
@@ -147,29 +204,6 @@ module Henitai
       )
     end
 
-    def qualify_namespace(namespace, name)
-      return name if namespace.nil? || namespace.empty?
-      return namespace if name.nil? || name.empty?
-
-      "#{namespace}::#{name}"
-    end
-
-    def constant_name(node)
-      return unless node.respond_to?(:type)
-
-      case node.type
-      when :const
-        parent_name = constant_name(node.children.first)
-        current_name = symbol_name(node.children.last)
-
-        return current_name if parent_name.nil? || parent_name.empty?
-
-        "#{parent_name}::#{current_name}"
-      when :cbase
-        ""
-      end
-    end
-
     def method_name(value)
       symbol_name(value)
     end