simplecov 1.0.3 → 1.1.0

data/lib/simplecov/static_coverage_extractor/condition_folding.rb

@@ -9,41 +9,231 @@ module SimpleCov
     # phantom that no loaded run can ever hit, the same unmergeable-tuple
     # failure mode 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.
+      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_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.
+      # 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.
+      # simplecov:disable branch — which arm runs is fixed by the running Ruby's version
       STATIC_CONDITION_TYPES = [
         ::Prism::IntegerNode, ::Prism::FloatNode, ::Prism::RationalNode,
         ::Prism::ImaginaryNode, ::Prism::SymbolNode, ::Prism::StringNode,
-        ::Prism::TrueNode, ::Prism::FalseNode, ::Prism::NilNode
+        ::Prism::TrueNode, ::Prism::FalseNode, ::Prism::NilNode,
+        ::Prism::SourceLineNode, ::Prism::SourceEncodingNode, ::Prism::LambdaNode,
+        *(::Prism::SourceFileNode if FOLDS_SOURCE_FILE)
+      ].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.
+      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
+      # 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.
+      STATIC_LITERAL_LEAF_TYPES = [
+        ::Prism::IntegerNode, ::Prism::FloatNode, ::Prism::RationalNode,
+        ::Prism::ImaginaryNode, ::Prism::StringNode, ::Prism::SymbolNode,
+        ::Prism::TrueNode, ::Prism::FalseNode, ::Prism::NilNode,
+        ::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.
+      PRISM_ERA_ELIMINABLE_READS = [
+        ::Prism::LocalVariableReadNode, ::Prism::InstanceVariableReadNode, ::Prism::DefinedNode
+      ].freeze
+
+      # simplecov:disable branch — which arm runs is fixed by the running Ruby's version
+      ELIMINABLE_READ_TYPES = [
+        ::Prism::SelfNode,
+        *(PRISM_ERA_ELIMINABLE_READS unless PARENS_ALWAYS_TRANSPARENT)
       ].freeze
+      # simplecov:enable branch
 
     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) }
+      # 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.
+      def visit_folded_arms(verdict, truthy_arm, falsy_arm)
+        live, dead = verdict == :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.
+        previous = @suppress_methods
+        begin
+          @suppress_methods = true
+          visit(arm)
+        ensure
+          @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.
+      #
+      # 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.
+      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
+      end
+
+      # A folding literal, minus the ones parentheses shield from the
+      # fold (`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) }
+
+        # 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
       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.
       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
+          break unless body.is_a?(::Prism::StatementsNode) && !body.body.empty?
+
+          statements = body.body
+          break unless statements.take(statements.size - 1).all? { |leading| eliminable_when_discarded?(leading) }
 
-          current = body.body.first
+          current = statements.last
         end
         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) }
+
+        node.is_a?(::Prism::ParenthesesNode) &&
+          node.body.is_a?(::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 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)
+        else false
+        end
+      end
+
+      def static_array_literal?(node)
+        node.elements.all? { |element| container_contents_eliminable?(element) }
+      end
+
+      def static_hash_literal?(node)
+        node.elements.all? do |element|
+          element.is_a?(::Prism::AssocNode) &&
+            container_contents_eliminable?(element.key) && container_contents_eliminable?(element.value)
+        end
+      end
+
+      def static_range_literal?(node)
+        [node.left, node.right].all? { |bound| bound.nil? || container_contents_eliminable?(bound) }
+      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
 end

data/lib/simplecov/static_coverage_extractor/location_conventions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "prism_compat"
+
 module SimpleCov
   module StaticCoverageExtractor
     # The source ranges Ruby's Coverage assigns to branch conditions and
@@ -34,11 +36,7 @@ module SimpleCov
       def if_like_location(node, type)
         return node.location unless LEGACY_COVERAGE_LOCATIONS && type == :if && elsif_node?(node)
 
-        content_end = legacy_content_end(node)
-        PointLocation.new(
-          start_line: node.location.start_line, start_column: node.location.start_column,
-          end_line: content_end.end_line, end_column: content_end.end_column
-        )
+        span(node.location, legacy_content_end(node))
       end
 
       def elsif_node?(node)
@@ -52,7 +50,7 @@ module SimpleCov
       def legacy_content_end(node)
         tail = node
         while tail.is_a?(::Prism::IfNode)
-          sub = tail.public_send(IF_NODE_SUBSEQUENT_METHOD)
+          sub = PrismCompat.subsequent(tail)
           break unless sub
 
           tail = sub
@@ -76,14 +74,12 @@ module SimpleCov
       end
 
       # Resolve the source range Coverage attributes to a real-or-synthetic
-      # `:else` arm of an if-like construct. IfNode uses
-      # `subsequent` / `consequent` and UnlessNode `else_clause` /
-      # `consequent`, both depending on Prism version (resolved to
-      # `IF_NODE_SUBSEQUENT_METHOD` / `ELSE_CLAUSE_METHOD` at load time).
-      # When neither is present, the synthesized else inherits the
-      # condition's range (matches Coverage's convention).
+      # `:else` arm of an if-like construct (`PrismCompat` hides the
+      # per-Prism-version accessor split). When no else/elsif is present,
+      # the synthesized else inherits the condition's range (matches
+      # Coverage's convention).
       def if_like_else_location(node, type)
-        sub = if_like_subsequent(node)
+        sub = PrismCompat.subsequent(node)
         return if_like_location(node, type) unless sub
         # An `elsif` arrives as a nested IfNode. Coverage attributes the
         # outer else arm to the clause's own range, not its then body
@@ -120,11 +116,7 @@ module SimpleCov
       end
 
       def legacy_when_value_location(case_node, when_node)
-        tail_end = legacy_case_tail_end(case_node, when_node)
-        PointLocation.new(
-          start_line: when_node.location.start_line, start_column: when_node.location.start_column,
-          end_line: tail_end.end_line, end_column: tail_end.end_column
-        )
+        span(when_node.location, legacy_case_tail_end(case_node, when_node))
       end
 
       # The last body content in the case after `when_node`, falling
@@ -141,7 +133,7 @@ module SimpleCov
         # condition when empty), so the whole clause extends the range
         # through trailing EMPTY clauses that have no `statements`.
         content = clauses.drop(index + 1).map(&:location)
-        else_statements = case_node.public_send(ELSE_CLAUSE_METHOD)&.statements
+        else_statements = PrismCompat.else_clause(case_node)&.statements
         content << else_statements.location if else_statements
         content
       end
@@ -152,7 +144,7 @@ module SimpleCov
       # explicit else with an empty body — the else..end span on modern
       # Rubies or the case's full range on legacy ones.
       def else_arm_location(node)
-        else_clause = node.public_send(ELSE_CLAUSE_METHOD)
+        else_clause = PrismCompat.else_clause(node)
         return node.location unless else_clause
         return else_clause.statements.location if else_clause.statements
         return else_clause.location unless LEGACY_COVERAGE_LOCATIONS
@@ -200,10 +192,14 @@ module SimpleCov
       # This convention is the same on legacy and modern Rubies. See
       # issue #1233.
       def safe_navigation_location(node)
-        end_loc = node.closing_loc || node.arguments&.location || node.message_loc
+        span(node.location, node.closing_loc || node.arguments&.location || node.message_loc)
+      end
+
+      # The range from `from`'s start through `to`'s end.
+      def span(from, to)
         PointLocation.new(
-          start_line: node.location.start_line, start_column: node.location.start_column,
-          end_line: end_loc.end_line, end_column: end_loc.end_column
+          start_line: from.start_line, start_column: from.start_column,
+          end_line: to.end_line, end_column: to.end_column
         )
       end
 
@@ -214,13 +210,6 @@ module SimpleCov
         )
       end
 
-      # The `else`/`elsif` clause of an if-like node, under whichever
-      # accessor this Prism version exposes (see the two *_METHOD
-      # constants).
-      def if_like_subsequent(node)
-        node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : node.public_send(ELSE_CLAUSE_METHOD)
-      end
-
       # Whether an empty then arm collapses to a point at the predicate's
       # end. Modern Coverage does this for every `if` (but not `unless`);
       # legacy Coverage does it only in void position, for both.

data/lib/simplecov/static_coverage_extractor/method_collector.rb

@@ -22,7 +22,14 @@ module SimpleCov
       # `def name(...)` and `def self.name(...)` both produce DefNode.
       # The class context is the surrounding lexical class/module (or
       # `Object` at the top level, matching `Coverage`'s convention).
+      # Suppression covers 3.2's folded dead arms, where nested branches
+      # stay instrumented but a `def` never registers (see
+      # Visitor#visit_dead_arm).
       def visit_def_node(node)
+        # simplecov:disable branch — suppression is reachable on 3.2 only
+        return super if @suppress_methods
+
+        # simplecov:enable branch
         loc = node.location
         class_name = @class_stack.last || "Object"
         key = [class_name, node.name, loc.start_line, loc.start_column, loc.end_line, loc.end_column]

data/lib/simplecov/static_coverage_extractor/prism_compat.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # The Prism 1.3 (Dec 2024) accessor renames for the trailing clause of
+    # conditional nodes, resolved ONCE at load so the per-node hot paths
+    # stay branch-free. Ruby 3.3's stdlib Prism (0.19) predates the
+    # renames; 3.4+ and any installed prism gem post-dates them. Reaching
+    # for the modern name on 0.19 raised NoMethodError inside the
+    # extractor — `call` swallowed it and the whole file silently fell
+    # back to no simulated data (see the 1.0.2 audit).
+    #
+    # This lives in its own file, required by every consumer, because the
+    # constants are referenced from several extractor files and defining
+    # them after those files were loaded worked only while the references
+    # happened at call time — a load-order trap for the next editor.
+    module PrismCompat
+    module_function
+
+      # `Prism::IfNode#subsequent` was renamed from `consequent`. The
+      # not-taken arm on whichever Prism version we're on can't be
+      # exercised by our own dogfood (we only run on one Prism at a time).
+      # simplecov:disable
+      IF_NODE_SUBSEQUENT_METHOD =
+        if ::Prism::IfNode.method_defined?(:subsequent)
+          :subsequent
+        else
+          :consequent
+        end
+
+      # The same rename hit the `else` accessor on `UnlessNode`,
+      # `CaseNode`, and `CaseMatchNode` (all three: `consequent` ->
+      # `else_clause`). All three renamed together, so one constant
+      # (probed off CaseNode) covers them.
+      ELSE_CLAUSE_METHOD =
+        if ::Prism::CaseNode.method_defined?(:else_clause)
+          :else_clause
+        else
+          :consequent
+        end
+      # simplecov:enable
+
+      # The `else`/`elsif` clause of an if-like node (an ElseNode, or a
+      # nested IfNode for `elsif`), or the `else` clause of anything else
+      # that has one, under whichever accessor this Prism exposes.
+      def subsequent(node)
+        node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : else_clause(node)
+      end
+
+      def else_clause(node)
+        node.public_send(ELSE_CLAUSE_METHOD)
+      end
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/value_position.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "prism_compat"
+
 module SimpleCov
   module StaticCoverageExtractor
     # Ruby 3.3 value-position analysis for the extractor's legacy branch
@@ -56,26 +58,16 @@ module SimpleCov
         return [node.body] if node.is_a?(::Prism::DefNode)
         return [] unless in_value
 
+        # `case/in` (CaseMatchNode) is intentionally not a tail construct:
+        # its `in` arms and `else` both discard tail position.
         case node
         when ::Prism::StatementsNode then [node.body.last]
-        when ::Prism::IfNode, ::Prism::UnlessNode then [node.statements, subsequent(node)]
-        when ::Prism::CaseNode then [*node.conditions, else_clause(node)]
+        when ::Prism::IfNode, ::Prism::UnlessNode then [node.statements, PrismCompat.subsequent(node)]
+        when ::Prism::CaseNode then [*node.conditions, PrismCompat.else_clause(node)]
         when ::Prism::ElseNode, ::Prism::WhenNode, ::Prism::BeginNode, ::Prism::ProgramNode then [node.statements]
         else []
         end
       end
-
-      # The `else`/`elsif` clause of an if-like node, and the `else` clause
-      # of a case, under whichever accessor this Prism version exposes.
-      # `case/in` (CaseMatchNode) is intentionally not a tail construct: its
-      # `in` arms and `else` both discard tail position.
-      def subsequent(node)
-        node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : else_clause(node)
-      end
-
-      def else_clause(node)
-        node.public_send(ELSE_CLAUSE_METHOD)
-      end
       # simplecov:enable
     end
   end

data/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "prism_compat"
 require_relative "condition_folding"
 require_relative "location_conventions"
 require_relative "method_collector"
@@ -7,42 +8,13 @@ require_relative "value_position"
 
 module SimpleCov
   module StaticCoverageExtractor
-    # `Prism::IfNode#subsequent` was renamed from `consequent` in Prism
-    # 1.3 (Dec 2024). Ruby 3.3's stdlib still ships an older Prism that
-    # only exposes `consequent`; 3.4+ and any project that's done
-    # `gem install prism` exposes `subsequent`. Resolve the method name
-    # ONCE here so the per-node hot path stays branch-free. The
-    # not-taken arm on whichever Prism version we're on can't be
-    # exercised by our own dogfood (we only run on one Prism at a time).
-    # simplecov:disable
-    IF_NODE_SUBSEQUENT_METHOD =
-      if ::Prism::IfNode.method_defined?(:subsequent)
-        :subsequent
-      else
-        :consequent
-      end
-
-    # The same Prism 1.3 rename hit the `else` accessor on `UnlessNode`,
-    # `CaseNode`, and `CaseMatchNode` (all three: `consequent` ->
-    # `else_clause`). Ruby 3.3's stdlib Prism (0.19) only exposes
-    # `consequent`, so reaching for `else_clause` there raised
-    # NoMethodError inside the extractor — `call` swallowed it and the
-    # whole file silently fell back to no simulated data for any
-    # `unless`/`else` or empty-arm `case`. Resolve the name once, like
-    # IF_NODE_SUBSEQUENT_METHOD. All three nodes renamed together, so one
-    # constant (probed off CaseNode) covers them.
-    ELSE_CLAUSE_METHOD =
-      if ::Prism::CaseNode.method_defined?(:else_clause)
-        :else_clause
-      else
-        :consequent
-      end
-    # simplecov:enable
-
     # Prism visitor that accumulates branch and method tuples in the
     # shape Ruby's `Coverage` reports. Tuple ids are sequential across
-    # the file — `Coverage` uses sequential ids too, so this matches the
-    # conventional shape. Only defined when Prism is loadable;
+    # the file like `Coverage`'s, but the numbering order can differ
+    # (e.g. `case`/`when` and chained `&.` are visited in a different
+    # order than Coverage numbers them). That's fine: the combiners
+    # intern on source span and the report output drops ids, so nothing
+    # downstream compares them. Only defined when Prism is loadable;
     # `StaticCoverageExtractor.available?` is the runtime gate.
     class Visitor < ::Prism::Visitor
       # Method tuples and the class/module nesting that names them are
@@ -64,6 +36,7 @@ module SimpleCov
         @next_id = 0
         @class_stack = []
         @value_positions = nil
+        @suppress_methods = false
       end
 
       # Entry point for a parsed file. On legacy Rubies the location of an
@@ -84,13 +57,27 @@ module SimpleCov
       # `else`, another IfNode for `elsif`). When the subsequent is
       # missing, Coverage synthesizes a `:else` arm attributed to the
       # whole condition's range — we do the same.
+      #
+      # A folded condition emits no tuple, and on modern Rubies only its
+      # live arm is descended into: the compiler eliminates the dead
+      # arm's entire subtree, so a branch or method nested there would be
+      # a phantom no loaded run can produce. A falsy `if`'s elsif chain
+      # survives as a plain `if`, which is what visiting the subsequent
+      # IfNode emits. On 3.2 the dead arm is visited too, branches only
+      # (see visit_folded_arms).
       def visit_if_node(node)
-        emit_if_like(node, :if) unless static_condition?(node.predicate)
+        verdict = folded_condition(node.predicate)
+        return visit_folded_arms(verdict, node.statements, PrismCompat.subsequent(node)) if verdict
+
+        emit_if_like(node, :if)
         super
       end
 
       def visit_unless_node(node)
-        emit_if_like(node, :unless) unless static_condition?(node.predicate)
+        verdict = folded_condition(node.predicate)
+        return visit_folded_arms(verdict, PrismCompat.else_clause(node), node.statements) if verdict
+
+        emit_if_like(node, :unless)
         super
       end
 

data/lib/simplecov/unloaded_file_injector.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "simulate_coverage"
+
+module SimpleCov
+  # Fills in coverage for files that were tracked (via `cover` / `track_files`)
+  # but never loaded, so they count toward the denominators instead of being
+  # absent from the report entirely.
+  #
+  # This is the mechanism; the merge-time policy of *when* to inject and
+  # which criteria the simulated files carry lives in
+  # `ResultMerger::UnloadedFiles` — easy names to confuse.
+  #
+  # Everything arrives as arguments rather than being read from the SimpleCov
+  # singleton. The merge step performs this injection on behalf of the processes
+  # that contributed to it, and it does not necessarily share their
+  # configuration: a standalone `collate` never ran `SimpleCov.start`, so it has
+  # no `cover` glob of its own and takes the tracked paths from the resultsets
+  # instead. See #1250.
+  module UnloadedFileInjector
+  module_function
+
+    # Expand `globs` into absolute paths, relative to `root` rather than
+    # `Dir.pwd` — test runners that chdir (or CI scripts that invoke the suite
+    # from a subdirectory) would otherwise silently miss files and produce a
+    # different set per environment. See #1106.
+    # `reject:` are the producing process's path-decidable filters. Paths its
+    # own report would exclude must not be recorded as tracked, or a merge that
+    # does not share the configuration would simulate them back in. Before
+    # injection moved to the merge the producer filtered them out of its own
+    # result and they never reached a resultset. A block filter is handed the
+    # source file and may consult coverage that does not exist yet, so those
+    # still fall to the merging process's filter chain. See #1250.
+    def discover(globs, root:, reject: [])
+      paths = globs.compact
+                   .flat_map { |glob| Dir.glob(glob, base: root) }
+                   .uniq
+                   .map { |path| File.expand_path(path, root) }
+      return paths if reject.empty?
+
+      paths.reject { |path| rejected?(path, reject) }
+    end
+
+    # `SourceFile` reads source and builds lines lazily, so a path-only filter
+    # answers without anything here touching disk.
+    def rejected?(path, filters)
+      candidate = SourceFile.new(path, NO_COVERAGE_YET, loaded: false)
+      filters.any? { |filter| filter.matches?(candidate) }
+    end
+
+    no_coverage_yet = {"lines" => []} #: Hash[String, Array[untyped]]
+    NO_COVERAGE_YET = no_coverage_yet.freeze
+    private_constant :NO_COVERAGE_YET
+
+    # Add simulated coverage for every path `coverage` does not already carry.
+    # Paths that are present are left alone, whoever put them there, which is
+    # what lets this run over resultsets a previous SimpleCov already injected
+    # into without double-counting or overwriting real data.
+    #
+    # Returns the augmented coverage and the set of paths that were added.
+    def call(coverage, paths, synthesize:, lines:)
+      injected = Set.new
+      augmented = coverage.dup
+
+      paths.each do |path|
+        next if augmented.key?(path)
+
+        augmented[path] = SimulateCoverage.call(path, synthesize: synthesize, lines: lines)
+        injected << path
+      end
+
+      [augmented, injected]
+    end
+  end
+end

data/lib/simplecov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end