simplecov 1.0.0 → 1.0.2

data/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb

@@ -15,7 +15,7 @@ module SimpleCov
       end
 
       def report
-        violations.each { |violation| warn SimpleCov::Color.colorize(message_for(violation), :red) }
+        violations.each { |violation| ExitCodes.print_error SimpleCov::Color.colorize(message_for(violation), :red) }
       end
 
       def exit_code

data/lib/simplecov/exit_codes/maximum_overall_coverage_check.rb

@@ -32,7 +32,7 @@ module SimpleCov
       end
 
       def report_violation(violation)
-        warn format(
+        ExitCodes.print_error format(
           "%<criterion>s coverage (%<actual>s) is above the expected maximum coverage (%<expected>.2f%%). " \
           "Time to bump the threshold!",
           criterion: violation.fetch(:criterion).capitalize,

data/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -17,7 +17,7 @@ module SimpleCov
 
       def report
         violations.each do |violation|
-          warn format(
+          ExitCodes.print_error format(
             "%<criterion>s coverage by file (%<actual>s) is below the expected minimum coverage " \
             "(%<expected>.2f%%) in %<filename>s.",
             criterion: violation.fetch(:criterion).capitalize,

data/lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb

@@ -16,7 +16,7 @@ module SimpleCov
 
       def report
         violations.each do |violation|
-          warn format(
+          ExitCodes.print_error format(
             "%<criterion>s coverage by group (%<actual>s) is below the expected minimum coverage " \
             "(%<expected>.2f%%) in %<group_name>s.",
             criterion: violation.fetch(:criterion).capitalize,

data/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -34,7 +34,7 @@ module SimpleCov
       def report_violation(violation)
         criterion = violation.fetch(:criterion)
         actual = violation.fetch(:actual)
-        warn format(
+        ExitCodes.print_error format(
           "%<criterion>s coverage (%<actual>s) is below the expected minimum coverage (%<expected>.2f%%).",
           criterion: criterion.capitalize,
           actual: SimpleCov::Color.colorize_percent(actual),
@@ -47,9 +47,9 @@ module SimpleCov
         worst = worst_files_for(criterion)
         return if worst.empty?
 
-        warn "  Lowest-coverage files (#{criterion}):"
+        ExitCodes.print_error "  Lowest-coverage files (#{criterion}):"
         worst.each do |path, percent|
-          warn format(
+          ExitCodes.print_error format(
             "    %<percent>s  %<path>s",
             percent: SimpleCov::Color.colorize_percent(percent, format("%6.2f%%", percent)),
             path: path

data/lib/simplecov/exit_codes.rb

@@ -1,12 +1,24 @@
 # frozen_string_literal: true
 
 module SimpleCov
+  # Exit statuses SimpleCov sets when coverage checks fail, and the output
+  # helper the enforcement machinery reports through.
   module ExitCodes
     SUCCESS = 0
     EXCEPTION = 1
     MINIMUM_COVERAGE = 2
     MAXIMUM_COVERAGE_DROP = 3
     MAXIMUM_COVERAGE = 4
+
+    # Threshold-violation reports and exit-status notices are the output of
+    # the enforcement feature, not Ruby warnings: routing them through
+    # `Kernel#warn` made `-W0` swallow the explanation for a failing exit
+    # code, let `Warning.warn` hooks (warning trackers, raise-on-warning
+    # test setups) intercept them mid-`at_exit`, and fed colorized text to
+    # warning logs. `print_errors false` remains the intended opt-out.
+    def self.print_error(message)
+      $stderr.puts message # rubocop:disable Style/StderrPuts
+    end
   end
 end
 

data/lib/simplecov/exit_handling.rb

@@ -56,7 +56,7 @@ module SimpleCov
     def warn_about_deferred_report
       return unless print_errors
 
-      warn SimpleCov::Color.colorize(
+      ExitCodes.print_error SimpleCov::Color.colorize(
         "Skipping SimpleCov report — this process tracked no application code and a newer " \
         "report already exists at #{coverage_path}. This usually means SimpleCov.start ran in a " \
         "parent process (e.g. a Rakefile or Rails' Bundler.require) that shelled out to the test " \
@@ -97,7 +97,7 @@ module SimpleCov
     # @api private
     def exit_and_report_previous_error(exit_status)
       if print_errors
-        warn SimpleCov::Color.colorize(
+        ExitCodes.print_error SimpleCov::Color.colorize(
           "Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected",
           :yellow
         )
@@ -124,7 +124,7 @@ module SimpleCov
       return unless exit_status.positive?
 
       if print_errors
-        warn SimpleCov::Color.colorize(
+        ExitCodes.print_error SimpleCov::Color.colorize(
           "SimpleCov failed with exit #{exit_status} due to a coverage related error", :red
         )
       end

data/lib/simplecov/file_list.rb

@@ -27,8 +27,8 @@ module SimpleCov
     # returns the `{line:, branch:, method:}` Hash; pass a criterion symbol
     # (`:line` / `:branch` / `:method`) to get that one CoverageStatistics.
     def coverage_statistics(criterion = nil)
-      @coverage_statistics ||= compute_coverage_statistics
-      criterion ? @coverage_statistics[criterion] : @coverage_statistics
+      stats = (@coverage_statistics ||= compute_coverage_statistics)
+      criterion ? stats[criterion] : stats
     end
 
     def coverage_statistics_by_file
@@ -67,7 +67,11 @@ module SimpleCov
 
     # Finds the least covered file and returns that file's name
     def least_covered_file
-      min_by(&:covered_percent).filename
+      # `covered_percent` is nil only for an unmeasured criterion, and :line
+      # is always measured, so the `|| 0.0` arm never fires at runtime; it
+      # (and the cast) exist to satisfy min_by's Comparable requirement.
+      least_covered = min_by { |file| file.covered_percent || 0.0 }
+      (_ = least_covered).filename
     end
 
     # Returns the overall amount of relevant lines of code across all files in this list
@@ -137,7 +141,10 @@ module SimpleCov
     # enabled set so disabled criteria don't surface in totals, JSON,
     # or the HTML report.
     def compute_coverage_statistics_by_file
-      seed = enabled_criteria_for_reporting.to_h { |criterion| [criterion, []] }
+      seed = enabled_criteria_for_reporting.to_h do |criterion|
+        bucket = [] #: Array[CoverageStatistics]
+        [criterion, bucket]
+      end
       @files.each_with_object(seed) do |file, together|
         file.coverage_statistics.each do |criterion, stats|
           together[criterion] << stats if together.key?(criterion)
@@ -153,7 +160,7 @@ module SimpleCov
     # criterion is enabled; the JRuby-gated branch/method criteria are
     # reported when they pass their own engine-support check.
     def enabled_criteria_for_reporting
-      criteria = []
+      criteria = [] #: Array[SimpleCov::criterion]
       criteria << :line   if SimpleCov.coverage_criterion_enabled?(:line) ||
                              SimpleCov.coverage_criterion_enabled?(:oneshot_line)
       criteria << :branch if SimpleCov.branch_coverage?

data/lib/simplecov/formatter/base.rb

@@ -45,7 +45,8 @@ module SimpleCov
       # confusing than the absolute form. See issue #197.
       def displayable_output_path
         directory = relative_or_absolute_output_path
-        entry_point_filename ? File.join(directory, entry_point_filename) : directory
+        entry_point = entry_point_filename
+        entry_point ? File.join(directory, entry_point) : directory
       end
 
       def relative_or_absolute_output_path

data/lib/simplecov/formatter/html_formatter.rb

@@ -31,8 +31,10 @@ module SimpleCov
 
         copy_static_assets
         # stderr, not stdout: this is a status message, not the program's
-        # output. Keeps the line out of pipelines like `rspec -f json`.
-        warn output_message(result) unless @silent
+        # output. Keeps the line out of pipelines like `rspec -f json`. And
+        # $stderr.puts, not `warn`: a status line should not reach
+        # `Warning.warn` hooks or vanish under `-W0` (see #1225).
+        $stderr.puts output_message(result) unless @silent # rubocop:disable Style/StderrPuts
       end
 
       # Generate HTML from a pre-existing coverage.json file without
@@ -65,14 +67,18 @@ module SimpleCov
       #   from opening the existing path for writing.
       def atomic_write(dest, content)
         temp = "#{dest}.#{Process.pid}.#{rand(2**32).to_s(36)}"
-        File.binwrite(temp, content)
-        File.rename(temp, dest)
-      ensure
-        FileUtils.rm_f(temp)
+        begin
+          File.binwrite(temp, content)
+          File.rename(temp, dest)
+        ensure
+          FileUtils.rm_f(temp)
+        end
       end
 
       def public_dir
-        File.join(__dir__, "html_formatter/public/")
+        # `.to_s` collapses `__dir__`'s nil arm (only possible under eval,
+        # which can't happen for a file on disk) so the path is a String.
+        File.join(__dir__.to_s, "html_formatter/public/")
       end
     end
   end

data/lib/simplecov/formatter/json_formatter/errors_formatter.rb

@@ -42,14 +42,20 @@ module SimpleCov
         end
 
         def record_by_file(violation)
-          file_bucket = bucket(:minimum_coverage_by_file)[violation.fetch(:project_filename)] ||= {}
+          by_file = bucket(:minimum_coverage_by_file)
+          file_bucket = by_file[violation.fetch(:project_filename)] ||= {} #: Hash[untyped, untyped]
           file_bucket[key_for(violation)] = expected_actual(violation)
         end
 
         def format_minimum_by_group
           violations = SimpleCov::CoverageViolations.minimum_by_group(@result, SimpleCov.minimum_coverage_by_group)
+          return if violations.empty?
+
+          # `bucket` lazily creates the errors key, so only touch it when
+          # there is a violation to record.
+          by_group = bucket(:minimum_coverage_by_group)
           violations.each do |violation|
-            group_bucket = bucket(:minimum_coverage_by_group)[violation.fetch(:group_name)] ||= {}
+            group_bucket = by_group[violation.fetch(:group_name)] ||= {} #: Hash[untyped, untyped]
             group_bucket[key_for(violation)] = expected_actual(violation)
           end
         end
@@ -68,7 +74,7 @@ module SimpleCov
         end
 
         def bucket(name)
-          @errors[name] ||= {}
+          @errors[name] ||= {} #: Hash[untyped, untyped]
         end
 
         def key_for(violation)

data/lib/simplecov/formatter/json_formatter/result_hash_formatter.rb

@@ -95,7 +95,7 @@ module SimpleCov
         end
 
         def format_coverage_statistics(statistics)
-          result = {}
+          result = {} #: Hash[Symbol, untyped]
           result[:lines]    = format_line_statistic(statistics[:line])      if statistics[:line]
           result[:branches] = format_single_statistic(statistics[:branch])  if statistics[:branch]
           result[:methods]  = format_single_statistic(statistics[:method])  if statistics[:method]

data/lib/simplecov/formatter/json_formatter/source_file_formatter.rb

@@ -13,7 +13,7 @@ module SimpleCov
         end
 
         def call
-          result = @include_source ? format_source_code : {}
+          result = @include_source ? format_source_code : {} #: Hash[Symbol, untyped]
           result.merge!(line_coverage_section) if line_coverage_enabled?
           result.merge!(branch_coverage_section) if SimpleCov.branch_coverage?
           result.merge!(method_coverage_section) if SimpleCov.method_coverage?

data/lib/simplecov/formatter/json_formatter.rb

@@ -28,8 +28,10 @@ module SimpleCov
         warn_if_concurrent_overwrite(path, result)
         File.write(path, JSON.pretty_generate(self.class.build_hash(result)))
         # stderr, not stdout: this is a status message, not the program's
-        # output. Keeps the line out of pipelines like `rspec -f json`.
-        warn output_message(result) unless @silent
+        # output. Keeps the line out of pipelines like `rspec -f json`. And
+        # $stderr.puts, not `warn`: a status line should not reach
+        # `Warning.warn` hooks or vanish under `-W0` (see #1225).
+        $stderr.puts output_message(result) unless @silent # rubocop:disable Style/StderrPuts
       end
 
     private

data/lib/simplecov/formatter/multi_formatter.rb

@@ -12,16 +12,21 @@ module SimpleCov
           formatters.map do |formatter|
             formatter.new.format(result)
           rescue StandardError => e
-            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{(_ = e.backtrace).first})")
             nil
           end
         end
       end
 
       def self.new(formatters = nil)
+        # Normalize eagerly and capture the list in the closure. Array()
+        # is pure for every accepted input shape (nil, single formatter,
+        # array, or another MultiFormatter class), so this is equivalent
+        # to the historical lazy per-instance memoization.
+        formatter_list = Array(formatters)
         Class.new do
           define_method :formatters do
-            @formatters ||= Array(formatters)
+            formatter_list
           end
           include InstanceMethods
         end

data/lib/simplecov/formatter/simple_formatter.rb

@@ -15,7 +15,9 @@ module SimpleCov
 
       def format_group(name, files)
         header = "Group: #{name}\n#{'=' * 40}\n"
-        body   = files.map { |file| "#{file.filename} (coverage: #{file.covered_percent.floor(2)}%)\n" }.join
+        # `covered_percent` is nilable across criteria, but line stats are
+        # always measured, so the no-argument call can't return nil here.
+        body   = files.map { |file| "#{file.filename} (coverage: #{(_ = file.covered_percent).floor(2)}%)\n" }.join
         "#{header}#{body}\n"
       end
     end

data/lib/simplecov/process.rb

@@ -9,7 +9,24 @@
 # correctly with other libraries doing the same — they each prepend
 # their own module and chain via `super`.
 
+# Reopened here for the fork-related at_exit plumbing that only matters
+# when subprocess support is loaded.
 module SimpleCov
+  class << self
+    # Forked children inherit at_exit state that is wrong for them:
+    # @at_exit_hook_installed may describe a hook the parent already
+    # consumed before forking (Minitest autorun runs the suite inside the
+    # parent's at_exit, after SimpleCov's own hook has fired), and
+    # external_at_exit may point at a Minitest.after_run deferral that is
+    # pid-pinned to the parent. Reset both so the at_fork proc's
+    # SimpleCov.start installs a fresh hook that actually fires at child
+    # exit. See issue #1227.
+    def reset_inherited_at_exit_state!
+      @at_exit_hook_installed = false
+      self.external_at_exit = false
+    end
+  end
+
   # Prepended onto Process's singleton class so every fork — direct or
   # via Kernel#fork / IO.popen — re-runs SimpleCov's at_fork callback in
   # the child.
@@ -27,6 +44,11 @@ module SimpleCov
         # the user installed, so `final_result_process?` can keep forked
         # workers from each producing the final report. See issue #1171.
         SimpleCov.mark_forked_subprocess!
+        # Without this, a child forked under Minitest autorun measures
+        # coverage and then silently discards it: every inherited exit
+        # route is dead in the child (see the method's comment). A custom
+        # at_fork runs afterwards and can still override. See issue #1227.
+        SimpleCov.reset_inherited_at_exit_state!
         SimpleCov.at_fork.call(::Process.pid)
       end
       pid

data/lib/simplecov/result_adapter.rb

@@ -27,13 +27,14 @@ module SimpleCov
 
     # Pre-0.18 resultsets pointed each filename straight at a line-coverage
     # array; everything since uses the `{lines:, branches:, methods:}`
-    # shape. Newer entries also need their methods table massaged before
-    # downstream code merges across processes.
+    # shape. Newer entries also need their methods and branches tables
+    # massaged before downstream code reports or merges them.
     def adapt_one(file_name, cover_statistic)
       return {"lines" => cover_statistic} if cover_statistic.is_a?(Array)
 
       adapt_oneshot_lines_if_needed(file_name, cover_statistic)
       normalize_method_keys(cover_statistic)
+      aggregate_duplicated_branches(cover_statistic)
       cover_statistic
     end
 
@@ -59,19 +60,53 @@ module SimpleCov
     SINGLETON_WRAPPER_PATTERN = /\A#<Class:([A-Z_][\w:]*)>\z/
     private_constant :SINGLETON_WRAPPER_PATTERN
 
+    # Ruby's method coverage records one entry per RECEIVER, not per source
+    # location: a block handed to `define_method` / `define_singleton_method`
+    # from a shared code path (a module's `included` hook, a builder) yields
+    # a separate `[receiver, name, location]` entry for every class it's
+    # defined on, all pointing at the same source. A file-based report can
+    # only express "was the method at this location ever executed", so
+    # entries are aggregated by (name, location), summing hits — otherwise
+    # each receiver whose copy never ran shows as a phantom uncovered method
+    # on a line whose line coverage is 100% (issue #1234). The first entry's
+    # (normalized) receiver is kept for display.
     def normalize_method_keys(cover_statistic)
       methods = cover_statistic[:methods]
       return unless methods
 
-      cover_statistic[:methods] = methods.each_with_object({}) do |(key, count), normalized|
-        normalized_key = key.dup
-        normalized_key[0] = key[0].to_s
-                                  .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
-                                  .sub(SINGLETON_WRAPPER_PATTERN, '\1')
-        # Keys may collide after normalization (anonymous classes sharing a
-        # method name, or singleton + instance forms of a module_function method).
-        normalized[normalized_key] = normalized.fetch(normalized_key, 0) + count
+      aggregated = {} #: Hash[untyped, [untyped, Integer]]
+      methods.each_with_object(aggregated) do |(key, count), memo|
+        identity = key[1..] #: Array[untyped]
+        retained_key, existing = memo[identity] || [normalize_method_key(key), 0]
+        memo[identity] = [retained_key, existing + count]
       end
+      cover_statistic[:methods] = aggregated.values.to_h
+    end
+
+    def normalize_method_key(key)
+      normalized_key = key.dup
+      normalized_key[0] = key[0].to_s
+                                .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
+                                .sub(SINGLETON_WRAPPER_PATTERN, '\1')
+      normalized_key
+    end
+
+    # Ruby's eval coverage records a fresh set of branch entries for every
+    # COMPILE of an eval'd string: a template rendered through multiple view
+    # classes (e.g. hanami-view compiles each template once per view) yields
+    # several `[:if, id, location]` conditions at identical coordinates in
+    # the same file, each counting only the renders that flowed through that
+    # compile. Reported as-is they inflate the branch denominator and turn a
+    # side covered under a different compile into a phantom miss (issue
+    # #1235). Aggregate them by (type, location) — combining a branches hash
+    # with an empty one dedups within it, since BranchesCombiner keys arms
+    # on location identity. Regular (non-eval) source can never produce two
+    # conditions at the same location, so this is a no-op outside eval.
+    def aggregate_duplicated_branches(cover_statistic)
+      branches = cover_statistic[:branches]
+      return unless branches
+
+      cover_statistic[:branches] = Combine::BranchesCombiner.combine(branches, {})
     end
 
     def adapt_oneshot_lines_if_needed(file_name, cover_statistic)

data/lib/simplecov/result_processing.rb

@@ -66,7 +66,7 @@ module SimpleCov
 
     # Applies the configured filters to the given array of SimpleCov::SourceFile items
     def filtered(files)
-      result = files.clone
+      result = files.to_a.dup
       filters.each do |filter|
         result = result.reject { |source_file| filter.matches?(source_file) }
       end
@@ -170,9 +170,9 @@ module SimpleCov
     # off); with merging on the merged result reports dropped source files,
     # so the per-process slice stays quiet to avoid one warning per worker.
     def process_coverage_result(report:)
-      @result = SimpleCov::UselessResultsRemover.call(Coverage.result)
-      @result = SimpleCov::ResultAdapter.call(@result)
-      result, not_loaded_files = add_not_loaded_files(@result)
+      raw = SimpleCov::UselessResultsRemover.call(Coverage.result)
+      adapted = SimpleCov::ResultAdapter.call(raw)
+      result, not_loaded_files = add_not_loaded_files(adapted)
       @result = SimpleCov::Result.new(result, not_loaded_files: not_loaded_files, report: report)
     end
   end

data/lib/simplecov/simulate_coverage.rb

@@ -39,8 +39,8 @@ module SimpleCov
       source_lines = read_lines(absolute_path)
       lines = coverage_stub(absolute_path, source_lines) ||
               LinesClassifier.new.classify(source_lines)
-      synthesized = StaticCoverageExtractor.call(source_lines.join) ||
-                    {"branches" => {}, "methods" => {}}
+      empty = {"branches" => {}, "methods" => {}} #: Hash[String, Hash[untyped, untyped]]
+      synthesized = StaticCoverageExtractor.call(source_lines.join) || empty
 
       {
         "lines" => lines,

data/lib/simplecov/source_file/line.rb

@@ -37,12 +37,12 @@ module SimpleCov
 
       # Returns true if this is a line that should have been covered, but was not
       def missed?
-        !never? && !skipped? && coverage.zero?
+        !never? && !skipped? && coverage.to_i.zero?
       end
 
       # Returns true if this is a line that has been covered
       def covered?
-        !never? && !skipped? && coverage.positive?
+        !never? && !skipped? && coverage.to_i.positive?
       end
 
       # Returns true if this line is not relevant for coverage

data/lib/simplecov/source_file/method.rb

@@ -34,7 +34,7 @@ module SimpleCov
       end
 
       def lines
-        @lines ||= start_line && end_line ? source_file.lines[(start_line - 1)..(end_line - 1)] : []
+        @lines ||= start_line && end_line ? source_file.lines[(start_line - 1)..(end_line - 1)] || [] : []
       end
 
       # Whether this method's source range intersects the given inclusive line range.

data/lib/simplecov/source_file/method_builder.rb

@@ -12,7 +12,9 @@ module SimpleCov
       end
 
       def call
-        methods = @source_file.coverage_data.fetch("methods", {}).filter_map do |info, hit_count|
+        none = {} #: Hash[untyped, Integer]
+        raw_methods = @source_file.coverage_data.fetch("methods", none)
+        methods = raw_methods.filter_map do |info, hit_count|
           info = RubyDataParser.call(info)
           next if eval_generated_to_ignore?(info)
 

data/lib/simplecov/source_file/source_loader.rb

@@ -14,12 +14,12 @@ module SimpleCov
     module_function
 
       def call(filename)
-        lines = []
+        lines = [] #: Array[String]
         # The default encoding is UTF-8
         File.open(filename, "rb:UTF-8") do |file|
           current_line = file.gets
 
-          if shebang?(current_line)
+          if current_line && shebang?(current_line)
             lines << current_line
             current_line = file.gets
           end

data/lib/simplecov/source_file.rb

@@ -51,8 +51,8 @@ module SimpleCov
     # returns the `{line:, branch:, method:}` Hash; pass a criterion symbol
     # (`:line` / `:branch` / `:method`) to get that one CoverageStatistics.
     def coverage_statistics(criterion = nil)
-      @coverage_statistics ||= Statistics.new(self).call
-      criterion ? @coverage_statistics[criterion] : @coverage_statistics
+      stats = (@coverage_statistics ||= Statistics.new(self).call)
+      criterion ? stats[criterion] : stats
     end
 
     # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,

data/lib/simplecov/static_coverage_extractor/condition_folding.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # Detects the `if` / `unless` / ternary conditions CRuby folds away.
+    # When a condition is a statically-known-truthy/falsy literal the
+    # compiler eliminates the dead arm and Coverage emits NO branch, so the
+    # extractor must not synthesize one either — otherwise the arm is a
+    # phantom that no loaded run can ever hit, the same unmergeable-tuple
+    # failure mode as #1226 / #1233.
+    module ConditionFolding
+      # Prism node types for the literals that fold. `while` / `until` do
+      # NOT fold (`while true` is a real branch), so only the if-like
+      # visitors consult this. Regexp and Range literals are excluded on
+      # purpose: as conditions they mean `=~ $_` / flip-flop, which
+      # Coverage does branch on.
+      STATIC_CONDITION_TYPES = [
+        ::Prism::IntegerNode, ::Prism::FloatNode, ::Prism::RationalNode,
+        ::Prism::ImaginaryNode, ::Prism::SymbolNode, ::Prism::StringNode,
+        ::Prism::TrueNode, ::Prism::FalseNode, ::Prism::NilNode
+      ].freeze
+
+    private
+
+      # Parentheses are transparent to the fold (`if (1)` folds like
+      # `if 1`), so see through a single parenthesized expression. Compound
+      # forms (`!true`, `true || x`) are deliberately not folded: `!` never
+      # folds, and `||` / `&&` constant-propagation diverges across Ruby
+      # versions, so matching it would trade a rare, version-specific gain
+      # for real risk.
+      def static_condition?(node)
+        node = unwrap_parentheses(node)
+        STATIC_CONDITION_TYPES.any? { |type| node.is_a?(type) }
+      end
+
+      def unwrap_parentheses(node)
+        # @type var current: untyped
+        current = node
+        while current.is_a?(::Prism::ParenthesesNode)
+          body = current.body
+          break unless body.is_a?(::Prism::StatementsNode) && body.body.size == 1
+
+          current = body.body.first
+        end
+        current
+      end
+    end
+  end
+end