simplecov 1.1.0 → 1.2.0

data/lib/simplecov/source_file/source_loader.rb

@@ -2,36 +2,35 @@
 
 module SimpleCov
   class SourceFile
-    # Reads a source file into an array of lines, honoring the source's
-    # shebang and `coding:` magic comment when present. Always
-    # transcodes to UTF-8 with invalid/undef bytes replaced — both for
-    # JRuby compatibility and to keep encoding shenanigans in one place
-    # (see #866).
+    # Reads a source file into an array of lines, honoring the source's shebang
+    # and `coding:` magic comment when present. Always transcodes to UTF-8 with
+    # invalid and undefined bytes replaced, both for JRuby compatibility and to
+    # keep encoding shenanigans in one place (#866).
     module SourceLoader
       SHEBANG_REGEX = /\A#!/
       RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = /\A#\s*(?:-\*-)?\s*(?:en)?coding:\s*(\S+)\s*(?:-\*-)?\s*\z/
 
-    module_function
+      extend self
 
       def call(filename)
         lines = [] #: Array[String]
-        # The default encoding is UTF-8
-        File.open(filename, "rb:UTF-8") do |file|
-          current_line = scrub_invalid(file.gets)
-
-          if current_line && shebang?(current_line)
-            lines << current_line
-            current_line = scrub_invalid(file.gets)
-          end
-
-          read_lines(file, lines, current_line)
+        open_file(filename, "rb:UTF-8") do |file|
+          read_lines(file, lines, scrub_invalid(file.gets))
         end
       end
 
-      # A line read as UTF-8 can still carry invalid bytes (a Latin-1
-      # source file without a magic comment, say). Replace them before
-      # any regex sees the line: the shebang and magic-comment checks
-      # would otherwise raise ArgumentError and take the report down.
+      # mutant:disable — Ruby 4.0 removed Kernel#open's leading-pipe
+      # command mode, so no test can tell `File.open` from `open` here
+      # any more. The explicit receiver is kept: on older rubies it is
+      # what refuses to run a filename as a command.
+      def open_file(name, mode, &)
+        File.open(name, mode, &)
+      end
+
+      # A line read as UTF-8 can still carry invalid bytes, from a Latin-1 source
+      # file without a magic comment, say. They are replaced before any regex sees
+      # the line: the shebang and magic-comment checks would otherwise raise
+      # ArgumentError and take the report down.
       def scrub_invalid(line)
         return line if line.nil? || line.valid_encoding?
 
@@ -45,11 +44,17 @@ module SimpleCov
       def read_lines(file, lines, current_line)
         return lines unless current_line
 
+        if shebang?(current_line)
+          lines << current_line
+          current_line = scrub_invalid(file.gets)
+          return lines unless current_line
+        end
+
         set_encoding_based_on_magic_comment(file, current_line)
         lines.concat([current_line], ensure_remove_undefs(file.readlines))
       end
 
-      # Encoding magic comment must be placed at first line except for
+      # An encoding magic comment must be placed on the first line, except after a
       # shebang.
       def set_encoding_based_on_magic_comment(file, line)
         if (match = RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX.match(line))
@@ -57,21 +62,26 @@ module SimpleCov
         end
       end
 
-      # Guarantee every line leaves the loader as valid UTF-8, replacing
-      # what can't be represented: transcode non-UTF-8 lines (setting
-      # invalid/undef options on `file.set_encoding` doesn't work
-      # properly, and this also works around a JRuby incompatibility)
-      # and scrub UTF-8-tagged lines that carry invalid bytes, which
-      # would otherwise raise from every regex the classifier runs.
+      # Setting invalid/undef options on `file.set_encoding` doesn't work
+      # properly, and transcoding here also works around a JRuby incompatibility.
       def ensure_remove_undefs(file_lines)
-        file_lines.each do |line|
-          # simplecov:disable — defensive: only fires for non-UTF-8 source files
-          if line.encoding == Encoding::UTF_8
-            line.scrub! unless line.valid_encoding?
-          else
-            line.encode!("UTF-8", invalid: :replace, undef: :replace)
-          end
-          # simplecov:enable
+        file_lines.each { |line| make_utf8(line) }
+      end
+
+      # mutant:disable — on CRuby the two arms answer alike, because
+      # converting to the encoding a string already carries scrubs it
+      # when `invalid: :replace` is given. The arms are kept apart for
+      # the engines where that conversion is the documented no-op it
+      # reads as, which is the same reason the transcode is here rather
+      # than on `file.set_encoding`.
+      # Encodings are singletons, so identity is the whole of the question. A line
+      # already tagged UTF-8 has nothing to transcode, only invalid bytes to
+      # replace, and scrubbing a line that has none of those leaves it alone.
+      def make_utf8(line)
+        if line.encoding.equal?(Encoding::UTF_8)
+          line.scrub!
+        else
+          line.encode!("UTF-8", invalid: :replace, undef: :replace)
         end
       end
     end

data/lib/simplecov/source_file/statistics.rb

@@ -2,10 +2,9 @@
 
 module SimpleCov
   class SourceFile
-    # Builds the `CoverageStatistics` triple (`:line`, `:branch`, `:method`)
-    # for a SourceFile, regardless of which criteria were actually enabled
-    # during the run — disabled or empty criteria collapse to 0/0/0 so
-    # downstream consumers don't have to special-case enable-state.
+    # Builds the `CoverageStatistics` triple for a SourceFile regardless of which
+    # criteria were enabled during the run: disabled or empty criteria collapse to
+    # 0/0/0 so downstream consumers don't have to special-case enable-state.
     class Statistics
       def initialize(source_file)
         @source_file = source_file
@@ -19,7 +18,7 @@ module SimpleCov
         }
       end
 
-    private
+      private
 
       def line_statistics
         {
@@ -31,13 +30,15 @@ module SimpleCov
         }
       end
 
-      # Files added via track_files but never loaded have no branch/method
-      # data. Report 0% instead of the empty-set default of 100% (see #902).
+      # Files added via track_files but never loaded have no branch or method data,
+      # and report 0% instead of the empty-set default of 100% (#902). A file with
+      # missed entries and none covered already computes to 0%, so only a file that
+      # really has covered entries keeps its computed percentage.
       def branch_statistics
         sf = @source_file
         covered = sf.covered_branches
         missed = sf.missed_branches
-        percent = 0.0 if sf.not_loaded? && covered.empty? && missed.empty?
+        percent = 0.0 if sf.not_loaded? && covered.empty?
 
         {branch: coverage_statistics(covered, missed, percent: percent)}
       end
@@ -46,7 +47,7 @@ module SimpleCov
         sf = @source_file
         covered = sf.covered_methods
         missed = sf.missed_methods
-        percent = 0.0 if sf.not_loaded? && covered.empty? && missed.empty?
+        percent = 0.0 if sf.not_loaded? && covered.empty?
 
         {method: coverage_statistics(covered, missed, percent: percent)}
       end

data/lib/simplecov/source_file.rb

@@ -12,17 +12,10 @@ require_relative "source_file/method_builder"
 require_relative "source_file/statistics"
 
 module SimpleCov
-  #
-  # Representation of a source file including it's coverage data, source code,
-  # source lines and featuring helpers to interpret that data.
-  #
   class SourceFile
     include BuilderContext
 
-    # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
-    attr_reader :filename
-    # The array of coverage data received from the Coverage.result
-    attr_reader :coverage_data
+    attr_reader :filename, :coverage_data
 
     def initialize(filename, coverage_data, loaded: true)
       @filename = filename
@@ -30,72 +23,57 @@ module SimpleCov
       @loaded = loaded
     end
 
-    # The path to this source file relative to the projects directory
     def project_filename
       @filename.delete_prefix(SimpleCov.root).sub(%r{\A[/\\]}, "")
     end
 
-    # The source code for this file. Aliased as :source.
-    # Intentionally read lazily to suppress reading unused source code.
+    # Read lazily to suppress reading unused source code.
     def src
       @src ||= SourceLoader.call(filename)
     end
-    alias source src
+    alias_method :source, :src
 
-    # Returns a hash keyed by every supported coverage criterion. Each
-    # value is a CoverageStatistics, even for criteria that weren't
-    # enabled during the run — those collapse to 0/0/0. Consumers
-    # (FileList, formatters) decide which keys to surface based on
-    # `SimpleCov.coverage_criterion_enabled?`.
     # The per-criterion coverage statistics for this file. With no argument
-    # returns the `{line:, branch:, method:}` Hash; pass a criterion symbol
-    # (`:line` / `:branch` / `:method`) to get that one CoverageStatistics.
+    # answers the `{line:, branch:, method:}` Hash, and with a criterion symbol
+    # that one CoverageStatistics. Every criterion is present even when it
+    # wasn't enabled during the run, collapsed to 0/0/0; `FileList` is the
+    # layer that filters to the enabled set.
     def coverage_statistics(criterion = nil)
       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,
-    # and thus including coverage data. Aliased as :source_lines
     def lines
       @lines ||= LineBuilder.new(self).call
     end
-    alias source_lines lines
+    alias_method :source_lines, :lines
 
-    # Returns all covered lines as SimpleCov::SourceFile::Line
     def covered_lines
       @covered_lines ||= lines.select(&:covered?)
     end
 
-    # Returns all lines that should have been, but were not covered
-    # as instances of SimpleCov::SourceFile::Line
     def missed_lines
       @missed_lines ||= lines.select(&:missed?)
     end
 
-    # Returns all lines that are not relevant for coverage as
-    # SimpleCov::SourceFile::Line instances
     def never_lines
       @never_lines ||= lines.select(&:never?)
     end
 
-    # Returns all lines that were skipped as SimpleCov::SourceFile::Line instances
     def skipped_lines
       @skipped_lines ||= lines.select(&:skipped?)
     end
 
-    # Returns the number of relevant lines (covered + missed)
     def lines_of_code
       coverage_statistics[:line]&.total || 0
     end
 
-    # Access SimpleCov::SourceFile::Line source lines by line number
+    # Answers nil for a number this file has no line for.
     def line(number)
-      lines[number - 1]
+      lines.at(number - 1)
     end
 
-    # The coverage for this file in percent, for the given criterion (line by
-    # default). Returns nil if the criterion was not measured.
+    # Nil if the criterion was not measured.
     def covered_percent(criterion = :line)
       coverage_statistics(criterion)&.percent
     end
@@ -104,15 +82,16 @@ module SimpleCov
       coverage_statistics(criterion)&.strength
     end
 
+    # Every line the file has is irrelevant, a file with no lines at all
+    # included.
     def no_lines?
-      lines.empty? || (lines.length == never_lines.size)
+      lines.all?(&:never?)
     end
 
     def relevant_lines
       lines.size - never_lines.size - skipped_lines.size
     end
 
-    # Return all the branches inside current source file
     def branches
       @branches ||= BranchBuilder.new(self).call
     end
@@ -121,33 +100,28 @@ module SimpleCov
       total_branches.empty?
     end
 
-    # DEPRECATED: use `covered_percent(:branch)`.
     def branches_coverage_percent
-      SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#branches_coverage_percent` is deprecated. " \
-                                  "Use `covered_percent(:branch)`.")
+      Deprecation.warn("`SimpleCov::SourceFile#branches_coverage_percent` is deprecated. " \
+                       "Use `covered_percent(:branch)`.")
       covered_percent(:branch)
     end
 
-    # Return the relevant branches to source file
     def total_branches
       @total_branches ||= covered_branches + missed_branches
     end
 
-    # Return hash with key of line number and branch coverage count as value
     def branches_report
       @branches_report ||=
         branches.reject(&:skipped?).group_by(&:report_line).transform_values { |bs| bs.map(&:report) }
     end
 
-    # Select the covered branches. We use a tree schema here because
-    # some conditions like `case` may have an additional `else` that
-    # isn't declared in code but is given by default by the coverage
-    # report.
+    # A tree schema, because some conditions like `case` may have an additional
+    # `else` that isn't declared in code but is given by default by the
+    # coverage report.
     def covered_branches
       @covered_branches ||= branches.select(&:covered?)
     end
 
-    # Select the missed branches with coverage equal to zero
     def missed_branches
       @missed_branches ||= branches.select(&:missed?)
     end
@@ -156,12 +130,10 @@ module SimpleCov
       branches_report.fetch(line_number, [])
     end
 
-    # Check if any branches missing on given line number
     def line_with_missed_branch?(line_number)
       branches_for_line(line_number).any? { |_type, count| count.zero? }
     end
 
-    # Return all methods detected in this source file
     def methods
       @methods ||= MethodBuilder.new(self).call
     end
@@ -174,14 +146,12 @@ module SimpleCov
       @missed_methods ||= methods.select(&:missed?)
     end
 
-    # DEPRECATED: use `covered_percent(:method)`.
     def methods_coverage_percent
-      SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#methods_coverage_percent` is deprecated. " \
-                                  "Use `covered_percent(:method)`.")
+      Deprecation.warn("`SimpleCov::SourceFile#methods_coverage_percent` is deprecated. " \
+                       "Use `covered_percent(:method)`.")
       covered_percent(:method)
     end
 
-    # Whether this file was added via track_files but never loaded/required.
     def not_loaded?
       !@loaded
     end

data/lib/simplecov/static_coverage_extractor/condition_folding.rb

@@ -2,39 +2,32 @@
 
 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.
+    # 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: the arm would be a phantom no loaded run
+    # can hit, the same unmergeable-tuple failure as #1226 / #1233.
     module ConditionFolding
-      # CRuby 3.4 rebuilt the fold on the Prism compiler, and the
-      # parse.y-based fold it replaced differed in three observable ways,
-      # each pinned by the runtime tuple equivalence battery on CI:
-      # `__FILE__` folded on 3.2/3.3 but no longer does; parentheses were
-      # transparent for every literal on 3.2 (opacity starts at 3.3); and
-      # on 3.2 the dead arm's branch table entries survive the fold —
-      # parse.y instrumented branches before eliminating dead code — while
-      # its `def`s still never register.
+      # CRuby 3.4 rebuilt the fold on the Prism compiler, and the parse.y fold it
+      # replaced differed in three observable ways: `__FILE__` folded on
+      # 3.2/3.3; parentheses were transparent for every literal on 3.2; and on
+      # 3.2 the dead arm's branch table entries survive the fold while its
+      # `def`s still never register.
       FOLDS_SOURCE_FILE = Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.4")
       PARENS_ALWAYS_TRANSPARENT = Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.3")
       DEAD_ARM_BRANCHES_SURVIVE = PARENS_ALWAYS_TRANSPARENT
-      # Container literals in discarded position are eliminated from 3.3
-      # on, but the contents rule differs: 3.3's compile.c elides a
-      # container whose contents are merely effect-free (`[x]`, `[self]`),
-      # while the Prism compiler (3.4+) demands fully static literals
-      # (`[1]` goes, `[x]` stays). See `static_container_literal?`.
+      # Container literals in discarded position are eliminated from 3.3 on, but
+      # 3.3's compile.c elides a container whose contents are merely
+      # effect-free (`[x]`), while the Prism compiler demands fully static
+      # literals (`[1]` goes, `[x]` stays).
       CONTAINER_CONTENTS_NEED_STATIC_LITERALS = !FOLDS_SOURCE_FILE
 
-      # 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. `[]`, `{}`, and interpolated strings do
-      # not fold either, and `->` folds while a `lambda` call does not —
-      # the compiler only folds what it can prove at compile time, and a
-      # method named `lambda` proves nothing.
+      # 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. `[]`, `{}`, and
+      # interpolated strings do not fold either, and `->` folds while a
+      # `lambda` call does not: a method named `lambda` proves nothing.
       # simplecov:disable branch — which arm runs is fixed by the running Ruby's version
       STATIC_CONDITION_TYPES = [
         ::Prism::IntegerNode, ::Prism::FloatNode, ::Prism::RationalNode,
@@ -45,27 +38,19 @@ module SimpleCov
       ].freeze
       # simplecov:enable branch
 
-      # The literals whose fold eliminates the *then* side: `if false` /
-      # `if nil` keep only the else arm. Every other folded literal is
-      # truthy and keeps only the then arm.
       FALSY_CONDITION_TYPES = [::Prism::FalseNode, ::Prism::NilNode].freeze
 
-      # The literals whose fold does NOT see through parentheses: CRuby
-      # folds `if nil`, `if "x"`, and `if -> {}` but keeps a real branch
-      # for `if (nil)`, `if ("x")`, and `if (-> {})` — verified against
-      # Coverage, and pinned by the runtime tuple equivalence battery —
-      # while every other literal folds parenthesized or not. `__FILE__`
-      # is opaque like other strings on the Rubies that fold it at all.
-      # Consulted only when PARENS_ALWAYS_TRANSPARENT is false.
+      # CRuby folds `if nil`, `if "x"`, and `if -> {}` but keeps a real branch
+      # for `if (nil)`, `if ("x")`, and `if (-> {})`, while every other literal
+      # folds parenthesized or not. Consulted only when parentheses are not
+      # always transparent.
       PAREN_OPAQUE_TYPES = [
         ::Prism::NilNode, ::Prism::StringNode, ::Prism::LambdaNode, ::Prism::SourceFileNode
       ].freeze
 
-      # The scalar literals the compiler treats as fully static: a
-      # multi-statement paren condition (`if (1; 2)`) folds by its last
+      # A multi-statement paren condition (`if (1; 2)`) folds by its last
       # expression only when every leading statement is eliminated when
-      # discarded, and these — bare or composing an Array/Hash/Range —
-      # always are. Pinned against real Coverage on 3.2 through 4.0.
+      # discarded, and these always are, bare or composing an Array/Hash/Range.
       STATIC_LITERAL_LEAF_TYPES = [
         ::Prism::IntegerNode, ::Prism::FloatNode, ::Prism::RationalNode,
         ::Prism::ImaginaryNode, ::Prism::StringNode, ::Prism::SymbolNode,
@@ -73,11 +58,9 @@ module SimpleCov
         ::Prism::SourceLineNode, ::Prism::SourceFileNode, ::Prism::SourceEncodingNode, ::Prism::RegularExpressionNode
       ].freeze
 
-      # Non-literal reads that are also eliminated when discarded.
-      # `self` is eliminated by every supported compiler; local/ivar/
-      # defined? elimination arrived with the Prism-era compilers.
-      # Anything that can raise or run hooks (constants, globals, calls,
-      # writes) is never eliminated and keeps the branch real.
+      # `self` is eliminated by every supported compiler; local/ivar/defined?
+      # elimination arrived with the Prism-era compilers. Anything that can
+      # raise or run hooks is never eliminated and keeps the branch real.
       PRISM_ERA_ELIMINABLE_READS = [
         ::Prism::LocalVariableReadNode, ::Prism::InstanceVariableReadNode, ::Prism::DefinedNode
       ].freeze
@@ -89,28 +72,21 @@ module SimpleCov
       ].freeze
       # simplecov:enable branch
 
-    private
+      private
 
-      # A truthy verdict keeps the first arm live, a falsy one the
-      # second. `visit` is nil-safe, so a missing arm just visits
-      # nothing. On 3.2 the dead arm's branch table entries survive the
-      # fold (parse.y instrumented branches before eliminating dead
-      # code, even inside dead `def` bodies and lambdas) while its
-      # methods never register, so the dead arm is visited with method
-      # collection suppressed.
+      # On 3.2 the dead arm's branch table entries survive the fold (parse.y
+      # instrumented branches before eliminating dead code) while its methods
+      # never register, so the dead arm is visited with method collection
+      # suppressed.
       def visit_folded_arms(verdict, truthy_arm, falsy_arm)
-        live, dead = verdict == :truthy ? [truthy_arm, falsy_arm] : [falsy_arm, truthy_arm]
+        live, dead = verdict.equal?(:truthy) ? [truthy_arm, falsy_arm] : [falsy_arm, truthy_arm]
         visit(live)
-        # simplecov:disable branch — the taken arm is fixed by the running Ruby's version
         visit_dead_arm(dead) if DEAD_ARM_BRANCHES_SURVIVE
-        # simplecov:enable branch
       end
 
-      # simplecov:disable — 3.2-only; unreachable on the modern dogfood Ruby
       def visit_dead_arm(arm)
-        # Save/restore rather than set/clear: a fold nested inside this
-        # dead arm re-enters here (possibly with a nil arm) and must not
-        # clear suppression for the rest of the outer dead arm.
+        # Save/restore rather than set/clear: a fold nested inside this dead arm
+        # re-enters here and must not clear suppression for the rest of it.
         previous = @suppress_methods
         begin
           @suppress_methods = true
@@ -119,54 +95,42 @@ module SimpleCov
           @suppress_methods = previous
         end
       end
-      # simplecov:enable
 
-      # The compiler's verdict on a condition: `:truthy` or `:falsy` when
-      # it folds, nil when it doesn't. The verdict decides which arm
-      # survives — the compiler eliminates the other arm's entire subtree,
-      # so everything inside it (nested branches, methods) must go
-      # unvisited too, not just the folded condition's own tuple.
+      # `:truthy` or `:falsy` when the compiler folds, nil when it doesn't. The
+      # compiler eliminates the losing arm's entire subtree, so everything
+      # inside it must go unvisited too, not just the folded condition's tuple.
       #
-      # Parentheses are transparent to the fold for most literals
-      # (`if (1)` folds like `if 1`) but not all — see
-      # PAREN_OPAQUE_TYPES. 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.
+      # 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 gain for real risk.
       def folded_condition(node)
         unwrapped = unwrap_parentheses(node)
         return nil unless foldable?(node, unwrapped)
 
-        FALSY_CONDITION_TYPES.any? { |type| unwrapped.is_a?(type) } ? :falsy : :truthy
+        (FALSY_CONDITION_TYPES.any? { |type| unwrapped.instance_of?(type) }) ? :falsy : :truthy
       end
 
-      # A folding literal, minus the ones parentheses shield from the
-      # fold (`unwrapped` differing from `node` is what says parentheses
-      # were seen through).
+      # `unwrapped` differing from `node` is what says parentheses were seen
+      # through.
       def foldable?(node, unwrapped)
-        return false unless STATIC_CONDITION_TYPES.any? { |type| unwrapped.is_a?(type) }
+        return false unless STATIC_CONDITION_TYPES.any? { |type| unwrapped.instance_of?(type) }
 
-        # simplecov:disable — which of these lines runs is fixed by the
-        # running Ruby's version: on 3.2 the early return always fires and
-        # the opacity check below it is dead code, so it must be excluded
-        # from line coverage too, not only branch coverage.
         return true if PARENS_ALWAYS_TRANSPARENT
 
-        unwrapped.equal?(node) || PAREN_OPAQUE_TYPES.none? { |type| unwrapped.is_a?(type) }
-        # simplecov:enable
+        unwrapped.equal?(node) || PAREN_OPAQUE_TYPES.none? { |type| unwrapped.instance_of?(type) }
       end
 
-      # Parentheses are transparent to the fold, and a multi-statement
-      # body (`if (1; 2)`) folds by its LAST expression — but only when
-      # the compiler eliminates every leading statement. Stopping at
-      # multi-statement bodies synthesized a phantom then/else pair no
-      # real run can ever hit.
+      # A multi-statement body (`if (1; 2)`) folds by its LAST expression, but
+      # only when the compiler eliminates every leading statement. Stopping at
+      # multi-statement bodies synthesized a phantom then/else pair.
       def unwrap_parentheses(node)
         # @type var current: untyped
         current = node
-        while current.is_a?(::Prism::ParenthesesNode)
+        while current.instance_of?(Prism::ParenthesesNode)
+          # Empty parentheses carry no statements node at all, so a
+          # body that is one always holds at least one statement.
           body = current.body
-          break unless body.is_a?(::Prism::StatementsNode) && !body.body.empty?
+          break unless body.instance_of?(Prism::StatementsNode)
 
           statements = body.body
           break unless statements.take(statements.size - 1).all? { |leading| eliminable_when_discarded?(leading) }
@@ -176,40 +140,27 @@ module SimpleCov
         current
       end
 
-      # Whether the compiler compiles `node` to nothing when its value is
-      # discarded.
       def eliminable_when_discarded?(node)
         return true if static_container_literal?(node)
-        return true if ELIMINABLE_READ_TYPES.any? { |type| node.is_a?(type) }
+        return true if ELIMINABLE_READ_TYPES.any? { |type| node.instance_of?(type) }
 
-        node.is_a?(::Prism::ParenthesesNode) &&
-          node.body.is_a?(::Prism::StatementsNode) &&
+        node.instance_of?(Prism::ParenthesesNode) &&
+          node.body.instance_of?(Prism::StatementsNode) &&
           node.body.body.all? { |statement| eliminable_when_discarded?(statement) }
       end
 
-      # A scalar literal leaf, or an Array/Hash/Range whose contents pass
-      # the running compiler's contents rule (see
-      # CONTAINER_CONTENTS_NEED_STATIC_LITERALS). Container elimination
-      # only exists from 3.3 on.
       def static_container_literal?(node)
-        return true if STATIC_LITERAL_LEAF_TYPES.any? { |type| node.is_a?(type) }
-        # simplecov:disable — which of these lines runs is fixed by the
-        # running Ruby's version: parse.y (3.2) never eliminates
-        # container literals, so there the early return always fires and
-        # the dispatch below is dead code.
+        return true if STATIC_LITERAL_LEAF_TYPES.any? { |type| node.instance_of?(type) }
         return false if PARENS_ALWAYS_TRANSPARENT
 
         static_container?(node)
-        # simplecov:enable
       end
 
-      # The container dispatch, version-free: the predicate specs
-      # exercise it directly on every supported Ruby, 3.2 included.
       def static_container?(node)
         case node
-        when ::Prism::ArrayNode then static_array_literal?(node)
-        when ::Prism::HashNode  then static_hash_literal?(node)
-        when ::Prism::RangeNode then static_range_literal?(node)
+        when Prism::ArrayNode then static_array_literal?(node)
+        when Prism::HashNode then static_hash_literal?(node)
+        when Prism::RangeNode then static_range_literal?(node)
         else false
         end
       end
@@ -220,7 +171,7 @@ module SimpleCov
 
       def static_hash_literal?(node)
         node.elements.all? do |element|
-          element.is_a?(::Prism::AssocNode) &&
+          element.instance_of?(Prism::AssocNode) &&
             container_contents_eliminable?(element.key) && container_contents_eliminable?(element.value)
         end
       end
@@ -230,9 +181,7 @@ module SimpleCov
       end
 
       def container_contents_eliminable?(node)
-        # simplecov:disable branch — which arm runs is fixed by the running Ruby's version
         CONTAINER_CONTENTS_NEED_STATIC_LITERALS ? static_container_literal?(node) : eliminable_when_discarded?(node)
-        # simplecov:enable branch
       end
     end
   end