henitai 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d11d8d5361258fac7bddc006b8fd8485d1d085c3eaf294afc5dc97c6eed9ee7c
-  data.tar.gz: c3620c79cd2b1e59ec43abb143775e0b5edcbc2ed89b3384caa39703e7b9759a
+  metadata.gz: 748dc8e07fefafa1e15d8f84b6e047896d20615362c1edc4d69e6321acd3db4d
+  data.tar.gz: d61c9559adc952e63417d3edffc9826093ea5e0e9b3298761badf85080e11a12
 SHA512:
-  metadata.gz: eed2ea62f262d95b79bae130a0d19437749c07b8873d532bd029755a72d9600335131167da004fe01dcb9d83427fb6155de1d841df4ea8dac0e2b4651de33d26
-  data.tar.gz: a4709f5c4804af79ea9599a62dfce714487c6d947bc8f85459cebebe206c4f0f7df965bff8c0aedacca227dceb67b32876733e9bfb450dc96357e2ef879f07c4
+  metadata.gz: 3172df8aa6dac29dd8498e0c2b697e0a1698a049ce86db1b976a5d93163206e146b16b2a641dd77088e0cc58e17238ffa657f704732a0e574d93a331faa80be0
+  data.tar.gz: 6458897e5a6c53321362b5f65cfd9018c8ca415ccad74a0ba8303c56336e182407b50cd3ac02d976bb55d2eb284444676de137719194c7bbb04f20717903f082

data/CHANGELOG.md

@@ -7,9 +7,89 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.3] - 2026-04-13
+
+### Added
+- Four new mutation operators: `UnaryOperator` (negates boolean and numeric
+  unary expressions), `UpdateOperator` (swaps `+=`/`-=`/`*=` and targets
+  compound-assignment nodes), `RegexMutator` (replaces regex literals with
+  never-match and always-match equivalents), and `MethodChainUnwrap` (removes
+  one step from a method chain to expose intermediate values)
+- `AvailableCpuCount`: container-aware CPU detection via cgroup v1/v2 and
+  cpuset files; the execution engine uses this to cap the default worker count
+  to the number of CPUs actually available to the process
+- `PerTestCoverageSelector`: narrows the candidate test set for each mutant
+  using per-test line-coverage data, reducing the number of processes forked
+  for targeted runs
+- `CoverageReportReader`: dedicated reader for `.resultset.json` and
+  `henitai_per_test.json`, giving `StaticFilter` and `PerTestCoverageSelector`
+  a single, tested JSON-parsing seam
+- Equivalence detection now covers logical identity patterns: `false || x`,
+  `x || false`, `true && x`, `x && true` are suppressed as equivalent mutants
+
+### Changed
+- Per-line mutation cap (`max_mutants_per_line`) removed from the generator,
+  configuration schema, and validator — see ADR-08. All syntactically valid
+  mutations on a line are now generated unconditionally
+- Default execution mode switched to linear (single-worker) as the
+  conservative, predictable baseline; parallel mode is still available via
+  configuration
+- `ParallelExecutionRunner` and `RspecProcessRunner` extracted from
+  `ExecutionEngine` and `Integration::Rspec` respectively, separating
+  orchestration concerns from integration concerns
+- `wait_with_timeout`, `cleanup_process_group`, and `reap_child` promoted to
+  public helpers on `Integration::Base` so `RspecProcessRunner` can call them
+  without reflection
+
+### Performance
+- Coverage bootstrap freshness check: the baseline RSpec run is skipped when
+  `.resultset.json` is newer than every watched source and test file,
+  eliminating ~83 % of bootstrap wall time on repeated runs within a session
+- Overlapped bootstrap: the baseline run starts in a background thread
+  immediately after subject resolution and runs concurrently with mutant
+  generation; only Gate 3 (StaticFilter) blocks on completion
+- Subject-scoped bootstrap: for targeted runs (`--since` / explicit subjects),
+  only the tests that cover the selected subjects are bootstrapped; falls back
+  to the full suite when the scoped set is empty
+- Automatic retry of the full bootstrap when a scoped bootstrap yields no
+  coverage candidates for a targeted run
+- `SourceParser` parse cache: each source file is parsed at most once per
+  pipeline run, removing duplicate parse calls between `SubjectResolver` and
+  `MutantGenerator`
+- `StaticFilter` path cache: `File.realpath` is called at most once per unique
+  path per filter invocation
+- `MutantGenerator::SubjectVisitor`: subject range boundaries are pre-computed
+  at visitor construction time, eliminating one `Range` allocation per visited
+  AST node
+
+### Fixed
+- Mutant child processes now run in isolated process groups (`setpgid`);
+  `cleanup_process_group` sends `SIGTERM` to the entire group on timeout or
+  error, preventing orphaned subprocesses
+- Pipeline error handling hardened across `CoverageBootstrapper`,
+  `ExecutionEngine`, `Runner`, and `SubjectResolver`: errors are surfaced
+  with a structured result instead of being swallowed silently
+- Report score thresholds now reflect the final aggregated result correctly
+- Three regressions introduced during the performance work resolved (path
+  normalisation, scoped bootstrap fallback, overlapped thread join order)
+- RBS/Steep signatures updated for bootstrap options, integration helpers,
+  result types, and the new operators
+
 ## [0.1.2] - 2026-04-07
 
+### Added
+- Method coverage is now enabled in both RSpec and Minitest bootstraps, and
+  the static filter merges method-level coverage into the line map
+
 ### Fixed
+- Coverage baseline regeneration now happens on every `henitai run`, so stale
+  coverage state does not leak between runs
+- Coverage handling now accepts symbol-keyed `Coverage.peek_result` output and
+  canonicalizes source file keys in `henitai_per_test.json`
+- Integration child processes isolate stdio correctly, and the integration
+  pause signature was restored so captured output stays stable
+- Coverage checks now consider the full mutant line range instead of only the
+  starting line
 - `Henitai::Mutant::Activator` now rewrites heredoc-backed method bodies from
   source slices instead of unparsing the whole body, eliminating timeouts on
   HTML reporter mutants
@@ -42,7 +122,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - CLI critical path: `henitai run` now executes the full pipeline, supports `--since`, returns CI-friendly exit codes, and `henitai version` prints `Henitai::VERSION`
 - RSpec per-test coverage output: `henitai/coverage_formatter` now writes `coverage/henitai_per_test.json`
 
-[Unreleased]: https://github.com/martinotten/henitai/compare/v0.1.2...HEAD
+[Unreleased]: https://github.com/martinotten/henitai/compare/v0.1.3...HEAD
+[0.1.3]: https://github.com/martinotten/henitai/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/martinotten/henitai/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/martinotten/henitai/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/martinotten/henitai/releases/tag/v0.1.0

data/README.md

@@ -71,7 +71,6 @@ includes:
 mutation:
   operators: light   # light | full
   timeout: 10.0
-  max_mutants_per_line: 1
   max_flaky_retries: 3
   sampling:
     ratio: 0.05
@@ -101,6 +100,9 @@ Per-test coverage reporting is currently wired through the RSpec child runner.
 Minitest integration reuses the same selection and execution flow, but does not
 yet enable the per-test coverage formatter.
 
+Henitai currently defaults to linear mutant execution. Set `jobs` in
+`.henitai.yml` or pass `--jobs N` to opt into parallel mutant execution.
+
 By default, Henitai keeps child test output out of the live terminal. Each
 baseline or mutant run writes captured stdout/stderr to `reports/mutation-logs/`
 and the terminal only shows progress plus a concise summary. Pass

data/assets/schema/henitai.schema.json

@@ -37,10 +37,6 @@
         "timeout": {
           "type": "number"
         },
-        "max_mutants_per_line": {
-          "type": "integer",
-          "minimum": 1
-        },
         "max_flaky_retries": {
           "type": "integer",
           "minimum": 0

data/lib/henitai/arid_node_filter.rb

@@ -38,6 +38,9 @@ module Henitai
       when :block
         block_match?(node)
       when :or_asgn
+        # Memoization-style ||= is treated as arid on purpose. UpdateOperator
+        # still mutates the &&= side of the logical pair, but the ||= source
+        # form is filtered here to avoid noisy mutants around memoization.
         true
       else
         false

data/lib/henitai/available_cpu_count.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module Henitai
+  # Detects the effective CPU count available to the current process.
+  class AvailableCpuCount
+    class << self
+      def detect
+        counts = [Etc.nprocessors, cgroup_cpu_quota, cpuset_cpu_count].compact.select(&:positive?)
+        counts.min || 1
+      end
+
+      private
+
+      def cgroup_cpu_quota
+        parse_cpu_max(read_limit("/sys/fs/cgroup/cpu.max")) ||
+          parse_cpu_cfs(
+            read_limit("/sys/fs/cgroup/cpu/cpu.cfs_quota_us"),
+            read_limit("/sys/fs/cgroup/cpu/cpu.cfs_period_us")
+          )
+      end
+
+      def cpuset_cpu_count
+        count_cpu_list(read_limit("/sys/fs/cgroup/cpuset.cpus.effective")) ||
+          count_cpu_list(read_limit("/sys/fs/cgroup/cpuset.cpus"))
+      end
+
+      def read_limit(path)
+        return unless File.file?(path)
+
+        File.read(path).strip
+      rescue Errno::ENOENT, Errno::EACCES
+        nil
+      end
+
+      def parse_cpu_max(value)
+        return if value.nil? || value.empty?
+
+        quota, period = value.split
+        return if quota == "max"
+
+        quota_count(quota, period)
+      end
+
+      def parse_cpu_cfs(quota, period)
+        return if quota.nil? || period.nil? || quota == "-1"
+
+        quota_count(quota, period)
+      end
+
+      def quota_count(quota, period)
+        quota_value = Integer(quota, 10)
+        period_value = Integer(period, 10)
+        return if quota_value <= 0 || period_value <= 0
+
+        [quota_value / period_value, 1].max
+      rescue ArgumentError
+        nil
+      end
+
+      def count_cpu_list(value)
+        return if value.nil? || value.empty?
+
+        value.split(",").sum { |entry| cpu_list_entry_size(entry) }
+      rescue ArgumentError
+        nil
+      end
+
+      def cpu_list_entry_size(entry)
+        from_text, to_text = entry.split("-", 2)
+        from = Integer(from_text, 10)
+        return 1 unless to_text
+
+        Integer(to_text, 10) - from + 1
+      end
+    end
+  end
+end

data/lib/henitai/cli.rb

@@ -12,7 +12,7 @@ module Henitai
   #   --use INTEGRATION Override integration from config (e.g. rspec)
   #   --config PATH     Path to .henitai.yml (default: .henitai.yml)
   #   --operators SET   Operator set: light (default) | full
-  #   --jobs N          Number of parallel workers (default: CPU count)
+  #   --jobs N          Number of parallel workers (default: 1)
   #   --all-logs        Print all captured child logs
   #   -h, --help        Show this help message
   #   -v, --version     Show version
@@ -25,7 +25,6 @@ module Henitai
       "mutation:",
       "  operators: light",
       "  timeout: 10.0",
-      "  max_mutants_per_line: 1",
       "  max_flaky_retries: 3",
       "  sampling:",
       "    ratio: 0.05",
@@ -51,7 +50,11 @@ module Henitai
       "PatternMatch" => ["Pattern matching", "in { x: Integer } -> in { x: String }"],
       "BlockStatement" => ["Block statements", "{ do_work } -> {}"],
       "MethodExpression" => ["Method calls", "call_service -> nil"],
-      "AssignmentExpression" => ["Assignment expressions", "x += 1 -> x -= 1"]
+      "AssignmentExpression" => ["Assignment expressions", "x += 1 -> x -= 1"],
+      "MethodChainUnwrap" => ["Method chain unwrap", "a.b.c -> a.b"],
+      "RegexMutator" => ["Regex literals", "/foo+/ -> /foo*/"],
+      "UnaryOperator" => ["Unary operators", "-x -> x"],
+      "UpdateOperator" => ["Compound assignment", "x += 1 -> x -= 1"]
     }.freeze
 
     def self.start(argv)
@@ -164,7 +167,7 @@ module Henitai
     end
 
     def add_jobs_option(opts, options)
-      opts.on("--jobs N", Integer, "Number of parallel workers") do |n|
+      opts.on("--jobs N", Integer, "Number of parallel workers (default: 1)") do |n|
         options[:jobs] = n
       end
     end

data/lib/henitai/configuration.rb

@@ -12,8 +12,7 @@ module Henitai
   class Configuration
     DEFAULT_TIMEOUT   = 10.0
     DEFAULT_OPERATORS = :light
-    DEFAULT_JOBS      = nil # auto-detect
-    DEFAULT_MAX_MUTANTS_PER_LINE = 1
+    DEFAULT_JOBS      = 1
     DEFAULT_MAX_FLAKY_RETRIES = 3
     DEFAULT_REPORTS_DIR = "reports"
     DEFAULT_COVERAGE_CRITERIA = {
@@ -25,7 +24,7 @@ module Henitai
     CONFIG_FILE        = ".henitai.yml"
 
     attr_reader :integration, :includes, :operators, :timeout,
-                :ignore_patterns, :max_mutants_per_line, :sampling, :jobs,
+                :ignore_patterns, :sampling, :jobs,
                 :max_flaky_retries, :coverage_criteria, :thresholds,
                 :reporters, :reports_dir,
                 :dashboard, :all_logs
@@ -71,7 +70,7 @@ module Henitai
                        integration
                      end
       @includes = raw[:includes] || ["lib"]
-      @jobs = raw[:jobs]
+      @jobs = raw.fetch(:jobs, DEFAULT_JOBS)
       @reporters = raw[:reporters] || ["terminal"]
       @reports_dir = raw[:reports_dir] || DEFAULT_REPORTS_DIR
       @all_logs = raw[:all_logs] == true
@@ -86,7 +85,6 @@ module Henitai
       @operators = (mutation[:operators] || DEFAULT_OPERATORS).to_sym
       @timeout = mutation[:timeout] || DEFAULT_TIMEOUT
       @ignore_patterns = mutation[:ignore_patterns] || []
-      @max_mutants_per_line = mutation[:max_mutants_per_line] || DEFAULT_MAX_MUTANTS_PER_LINE
       @max_flaky_retries = if mutation.key?(:max_flaky_retries)
                              mutation[:max_flaky_retries]
                            else

data/lib/henitai/configuration_validator.rb

@@ -16,7 +16,7 @@ module Henitai
       dashboard
       jobs
     ].freeze
-    VALID_MUTATION_KEYS = %i[operators timeout ignore_patterns max_mutants_per_line max_flaky_retries sampling].freeze
+    VALID_MUTATION_KEYS = %i[operators timeout ignore_patterns max_flaky_retries sampling].freeze
     VALID_SAMPLING_KEYS = %i[ratio strategy].freeze
     VALID_COVERAGE_CRITERIA_KEYS = %i[test_result timeout process_abort].freeze
     VALID_THRESHOLDS_KEYS = %i[high low].freeze
@@ -110,7 +110,6 @@ module Henitai
 
       def validate_mutation_limits(value)
         validate_timeout(value[:timeout])
-        validate_max_mutants_per_line(value[:max_mutants_per_line])
         validate_max_flaky_retries(value[:max_flaky_retries])
       end
 
@@ -202,15 +201,6 @@ module Henitai
         end
       end
 
-      def validate_max_mutants_per_line(value)
-        return if value.nil?
-        return if value.is_a?(Integer) && value >= 1
-
-        configuration_error(
-          "Invalid configuration value for mutation.max_mutants_per_line: expected Integer >= 1, got #{value.inspect}"
-        )
-      end
-
       def validate_max_flaky_retries(value)
         return if value.nil?
         return if value.is_a?(Integer) && value >= 0

data/lib/henitai/coverage_bootstrapper.rb

@@ -7,10 +7,26 @@ module Henitai
       @static_filter = static_filter
     end
 
-    def ensure!(source_files:, config:, integration:)
+    # Runs the test suite to collect coverage, unless a fresh report already
+    # exists.
+    #
+    # @param source_files [Array<String>] lib files whose coverage must be present
+    # @param config       [Configuration]
+    # @param integration  [Integration::Base]
+    # @param test_files   [Array<String>, nil] test files to run; defaults to
+    #                     all files reported by the integration when nil
+    def ensure!(source_files:, config:, integration:, test_files: nil)
       return if source_files.empty?
 
-      bootstrap_coverage(integration, config)
+      # Skip the bootstrap only when the coverage artifacts are both newer than
+      # all watched files and actually cover the configured sources. A fresh
+      # but irrelevant report (e.g. from a different working directory) must
+      # still trigger a re-bootstrap rather than silently proceeding with no
+      # usable coverage.
+      unless coverage_ready?(source_files, config, integration, test_files)
+        bootstrap_coverage(integration, config, test_files)
+      end
+
       return if coverage_available?(source_files, config)
 
       raise CoverageError,
@@ -29,16 +45,43 @@ module Henitai
       end
     end
 
+    def coverage_ready?(source_files, config, integration, test_files)
+      coverage_fresh?(source_files, config, integration, test_files) &&
+        coverage_available?(source_files, config) &&
+        per_test_coverage_ready?(source_files, config, integration, test_files)
+    end
+
     def source_file_paths(source_files)
       Array(source_files).map { |path| File.expand_path(path) }
     end
 
-    def bootstrap_coverage(integration, config)
-      with_coverage_dir(config) do
-        result = integration.run_suite(integration.test_files)
-        return if result == :survived
+    # Returns true when a coverage report already exists and is newer than
+    # every watched source and test file. Stale or absent reports return false.
+    def coverage_fresh?(source_files, config, integration, test_files)
+      watched_files_fresh?(
+        coverage_report_path(config),
+        source_files,
+        integration,
+        test_files
+      )
+    end
+
+    def coverage_report_path(config)
+      File.join(coverage_dir(config), ".resultset.json")
+    end
+
+    def per_test_coverage_report_path(config)
+      File.join(reports_dir(config), "henitai_per_test.json")
+    end
+
+    def bootstrap_coverage(integration, config, test_files = nil)
+      with_reports_dir(config) do
+        with_coverage_dir(config) do
+          result = integration.run_suite(test_files || integration.test_files)
+          return if result == :survived
 
-        raise CoverageError, build_bootstrap_error(result)
+          raise CoverageError, build_bootstrap_error(result)
+        end
       end
     end
 
@@ -64,11 +107,73 @@ module Henitai
       end
     end
 
+    def with_reports_dir(config)
+      original_reports_dir = ENV.fetch("HENITAI_REPORTS_DIR", nil)
+      ENV["HENITAI_REPORTS_DIR"] = reports_dir(config)
+      yield
+    ensure
+      if original_reports_dir.nil?
+        ENV.delete("HENITAI_REPORTS_DIR")
+      else
+        ENV["HENITAI_REPORTS_DIR"] = original_reports_dir
+      end
+    end
+
     def coverage_dir(config)
       reports_dir = config.respond_to?(:reports_dir) ? config.reports_dir : nil
       return "coverage" if reports_dir.nil? || reports_dir.empty?
 
       File.join(reports_dir, "coverage")
     end
+
+    def per_test_coverage_fresh?(source_files, config, integration, test_files)
+      watched_files_fresh?(
+        per_test_coverage_report_path(config),
+        source_files,
+        integration,
+        test_files
+      )
+    end
+
+    def per_test_coverage_available?(config)
+      File.exist?(per_test_coverage_report_path(config))
+    end
+
+    def per_test_coverage_ready?(source_files, config, integration, test_files)
+      return true unless per_test_coverage_supported?(integration)
+
+      per_test_coverage_fresh?(source_files, config, integration, test_files) &&
+        per_test_coverage_available?(config)
+    end
+
+    def per_test_coverage_supported?(integration)
+      return false unless integration.respond_to?(:per_test_coverage_supported?)
+
+      integration.per_test_coverage_supported?
+    end
+
+    def watched_files_fresh?(report_path, source_files, integration, test_files)
+      # This check assumes a single writer owns the coverage artifacts for the
+      # workspace. It is intentionally not an atomic snapshot-and-validate step.
+      return false unless File.exist?(report_path)
+
+      report_mtime = File.mtime(report_path)
+      watched_files(source_files, integration, test_files).all? do |path|
+        File.mtime(path) <= report_mtime
+      rescue Errno::ENOENT
+        false
+      end
+    end
+
+    def watched_files(source_files, integration, test_files)
+      Array(source_files) + Array(test_files || integration.test_files)
+    end
+
+    def reports_dir(config)
+      return "coverage" unless config.respond_to?(:reports_dir)
+      return "coverage" if config.reports_dir.nil? || config.reports_dir.empty?
+
+      config.reports_dir
+    end
   end
 end

data/lib/henitai/coverage_report_reader.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Henitai
+  # Reads coverage report formats used by Henitai.
+  class CoverageReportReader
+    DEFAULT_COVERAGE_REPORT_PATH = "coverage/.resultset.json"
+    DEFAULT_PER_TEST_COVERAGE_REPORT_PATH = "coverage/henitai_per_test.json"
+
+    def coverage_lines_by_file(path = DEFAULT_COVERAGE_REPORT_PATH)
+      return {} unless File.exist?(path)
+
+      coverage = Hash.new { |hash, key| hash[key] = [] }
+      JSON.parse(File.read(path)).each_value do |result|
+        result.fetch("coverage", {}).each do |file, file_coverage|
+          coverage[normalize_path(file)].concat(covered_lines(file_coverage))
+        end
+      end
+
+      coverage.transform_values(&:uniq).transform_values(&:sort)
+    end
+
+    def test_lines_by_file(path = DEFAULT_PER_TEST_COVERAGE_REPORT_PATH)
+      return {} unless File.exist?(path)
+
+      parsed = JSON.parse(File.read(path))
+      return {} unless parsed.is_a?(Hash)
+
+      parsed.transform_values do |coverage|
+        normalize_test_coverage(coverage)
+      end
+    end
+
+    private
+
+    def covered_lines(file_coverage)
+      Array(file_coverage["lines"]).each_with_index.filter_map do |count, index|
+        index + 1 if count.to_i.positive?
+      end
+    end
+
+    def normalize_test_coverage(coverage)
+      case coverage
+      when Hash
+        coverage.transform_values do |lines|
+          Array(lines).grep(Integer).uniq.sort
+        end
+      else
+        Array(coverage).grep(Integer).uniq.sort
+      end
+    end
+
+    def normalize_path(path)
+      @normalize_path_cache ||= {}
+      return @normalize_path_cache[path] if @normalize_path_cache.key?(path)
+
+      expanded = File.expand_path(path)
+      resolved = begin
+        File.realpath(expanded)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        expanded
+      end
+      @normalize_path_cache[path] = resolved
+    end
+  end
+end

data/lib/henitai/eager_load.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "henitai"
+
+# Force all autoloaded constants to load so mutation testing tools
+# (e.g. mutant) can discover subjects via ObjectSpace.
+SIDE_EFFECT_FILES = %w[minitest_simplecov.rb rspec_coverage_formatter.rb].freeze
+
+Dir[File.join(__dir__, "**/*.rb")].each do |f|
+  require f unless SIDE_EFFECT_FILES.any? { |name| f.end_with?(name) }
+end

data/lib/henitai/equivalence_detector.rb

@@ -10,7 +10,7 @@ module Henitai
   # obvious enough to be useful.
   class EquivalenceDetector
     def analyze(mutant)
-      return mutant unless equivalent_arithmetic_mutation?(mutant)
+      return mutant unless equivalent_mutation?(mutant)
 
       mutant.status = :equivalent
       mutant
@@ -18,6 +18,10 @@ module Henitai
 
     private
 
+    def equivalent_mutation?(mutant)
+      equivalent_arithmetic_mutation?(mutant) || equivalent_logical_mutation?(mutant)
+    end
+
     def equivalent_arithmetic_mutation?(mutant)
       original = mutant.original_node
       mutated = mutant.mutated_node
@@ -50,6 +54,61 @@ module Henitai
         one_operand?(mutated)
     end
 
+    def equivalent_logical_mutation?(mutant)
+      original = mutant.original_node
+      mutated = mutant.mutated_node
+      return false unless logical_node?(original)
+
+      logical_identity_equivalent?(original, mutated)
+    end
+
+    def logical_node?(node)
+      node.is_a?(Parser::AST::Node) && %i[and or].include?(node.type)
+    end
+
+    def logical_identity_equivalent?(original, mutated)
+      case original.type
+      when :or
+        false_identity_equivalent?(original, mutated)
+      when :and
+        true_identity_equivalent?(original, mutated)
+      else
+        false
+      end
+    end
+
+    def false_identity_equivalent?(original, mutated)
+      return true if false_operand?(original.children[0]) && same_node?(mutated, original.children[1])
+      return true if false_operand?(original.children[1]) && same_node?(mutated, original.children[0])
+
+      false
+    end
+
+    def true_identity_equivalent?(original, mutated)
+      return true if true_operand?(original.children[0]) && same_node?(mutated, original.children[1])
+      return true if true_operand?(original.children[1]) && same_node?(mutated, original.children[0])
+
+      false
+    end
+
+    def false_operand?(node)
+      # Parser uses :true / :false node types, so the AST symbols are intentional.
+      # rubocop:disable Lint/BooleanSymbol
+      boolean_literal?(node, :false)
+      # rubocop:enable Lint/BooleanSymbol
+    end
+
+    def true_operand?(node)
+      # Parser uses :true / :false node types, so the AST symbols are intentional.
+      # rubocop:disable Lint/BooleanSymbol
+      boolean_literal?(node, :true)
+      # rubocop:enable Lint/BooleanSymbol
+    end
+
+    def boolean_literal?(node, type)
+      node.is_a?(Parser::AST::Node) && node.type == type && node.children.empty?
+    end
+
     def additive_operator?(operator)
       %i[+ -].include?(operator)
     end