simplecov 1.0.0 → 1.1.1

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "prism_compat"
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # Ruby 3.3 value-position analysis for the extractor's legacy branch
+    # conventions (see LocationConventions and the #1233 audit).
+    #
+    # On Ruby 3.3, the source range Coverage assigns to an EMPTY branch arm
+    # depends on whether its construct is in value position — its result is
+    # the method's return value — or void position, where the result is
+    # discarded. Value position keeps the whole-construct range; void
+    # collapses the arm to a point at its header's end. Ruby 3.4 dropped the
+    # distinction, so this pass only runs on legacy Rubies.
+    #
+    # "Value position" here is narrower than general value-use: it is
+    # strictly method-return (tail) position. It reaches a node only through
+    # statement tails and `if`/`unless`/`when` arms. Assignments, blocks,
+    # lambdas, method arguments, `case/in` arms, and loop bodies all discard
+    # it (Coverage treats their empty arms as void). So `tail_children`
+    # names the constructs that forward tail position and everything else
+    # falls through to the void default.
+    module ValuePositions
+    module_function
+
+      # simplecov:disable
+      # This whole pass runs only on legacy Rubies (the modern dogfood
+      # never calls it), so its lines can't be covered on the CI Ruby that
+      # enforces 100%. Behavior is pinned instead by the differential
+      # tuple-equivalence spec, which runs against real Coverage on 3.3.
+
+      # An identity set (a `compare_by_identity` Hash used as a set) of the
+      # Prism nodes Coverage treats as being in value position.
+      def call(root)
+        positions = {} #: Hash[untyped, bool]
+        positions.compare_by_identity
+        mark(root, true, positions)
+        positions
+      end
+
+      def mark(node, in_value, positions)
+        return unless node.is_a?(::Prism::Node)
+
+        positions[node] = true if in_value
+        children = tail_children(node, in_value)
+        node.compact_child_nodes.each do |child|
+          mark(child, children.any? { |c| c.equal?(child) }, positions)
+        end
+      end
+
+      # The children of `node` that inherit its tail position; empty for the
+      # void default. A method body is a tail context even when the `def`
+      # itself is not (the method still returns its last expression), so it
+      # is included regardless of `in_value`.
+      def tail_children(node, in_value)
+        # A method body is a tail context even when the `def` is not.
+        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, 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
+      # simplecov:enable
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -1,34 +1,31 @@
 # frozen_string_literal: true
 
+require_relative "prism_compat"
+require_relative "condition_folding"
+require_relative "location_conventions"
 require_relative "method_collector"
+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
-    # 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
       # collected by this mixin; this class focuses on branch extraction.
       include MethodCollector
+      # Source-range resolution, including the per-Ruby-version Coverage
+      # conventions. See issue #1226.
+      include LocationConventions
+      # Which literal `if`/`unless`/ternary conditions the compiler folds
+      # away (so we emit no branch for them).
+      include ConditionFolding
 
       attr_reader :branches, :methods
 
@@ -38,6 +35,20 @@ module SimpleCov
         @methods = {}
         @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
+      # empty branch arm depends on whether its construct is in value
+      # (tail) position, so precompute that once for the whole tree before
+      # emitting anything. Modern Rubies don't need it (see
+      # LocationConventions), so the pass is skipped there.
+      def visit_program_node(node)
+        # simplecov:disable branch — legacy-only arm; unreachable on the modern dogfood Ruby
+        @value_positions = ValuePositions.call(node) if LEGACY_COVERAGE_LOCATIONS
+        # simplecov:enable branch
+        super
       end
 
       # `if` / `unless` / postfix-if / postfix-unless / ternary all parse
@@ -46,12 +57,26 @@ 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)
+        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)
+        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
@@ -74,6 +99,24 @@ module SimpleCov
         super
       end
 
+      # One-line pattern matching: `x => pattern` (MatchRequiredNode) and
+      # `x in pattern` (MatchPredicateNode). Ruby 3.3's Coverage reports
+      # these as a `:case` with an `:in` and an `:else` arm; 3.4 dropped
+      # them entirely (no branch), so this is legacy-only. The two forms
+      # differ only in where Coverage anchors the synthesized `:else`:
+      # `=>` uses the whole expression, `in` uses just the pattern.
+      # simplecov:disable branch — legacy-only arms; unreachable on the modern dogfood Ruby
+      def visit_match_required_node(node)
+        emit_oneline_pattern(node, node.location) if LEGACY_COVERAGE_LOCATIONS
+        super
+      end
+
+      def visit_match_predicate_node(node)
+        emit_oneline_pattern(node, node.pattern.location) if LEGACY_COVERAGE_LOCATIONS
+        super
+      end
+      # simplecov:enable branch
+
       # `while` / `until` loops get a single `:body` arm. No synthetic
       # else (the loop either runs the body or doesn't).
       def visit_while_node(node)
@@ -92,75 +135,44 @@ module SimpleCov
       # optional else/elsif) but expose the trailing arm under different
       # accessors. `if_like_else_location` hides that split.
       def emit_if_like(node, type)
-        then_loc = arm_location(node.statements, node.location)
-        else_loc = if_like_else_location(node)
-        @branches[build_tuple(type, node.location)] = {
+        then_loc = if_like_then_location(node, type)
+        else_loc = if_like_else_location(node, type)
+        @branches[build_tuple(type, if_like_location(node, type))] = {
           build_tuple(:then, then_loc) => 0,
           build_tuple(:else, else_loc) => 0
         }
       end
 
       def emit_safe_navigation(node)
-        loc = node.location
+        loc = safe_navigation_location(node)
         @branches[build_tuple(:"&.", loc)] = {
           build_tuple(:then, loc) => 0,
           build_tuple(:else, loc) => 0
         }
       end
 
-      # Resolve the source range Coverage attributes to a real-or-synthetic
-      # `:else` arm of an if-like construct. IfNode uses
-      # `subsequent` / `consequent` depending on Prism version (resolved
-      # to `IF_NODE_SUBSEQUENT_METHOD` at load time); UnlessNode uses
-      # `else_clause`. When neither is present, the synthesized else
-      # inherits the whole condition's range (matches Coverage's
-      # convention).
-      def if_like_else_location(node)
-        sub = node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : node.else_clause
-        return node.location unless sub
-
-        arm_location(else_body_of(sub), sub.location)
+      # simplecov:disable — legacy-only (3.4 emits no branch for one-line patterns)
+      def emit_oneline_pattern(node, else_location)
+        @branches[build_tuple(:case, node.location)] = {
+          build_tuple(:in, node.pattern.location) => 0,
+          build_tuple(:else, else_location) => 0
+        }
       end
+      # simplecov:enable
 
       def emit_case_like(node, when_type)
         arms = node.conditions.to_h do |when_node|
-          loc = arm_location(when_node.statements, when_node.location)
-          [build_tuple(when_type, loc), 0]
+          [build_tuple(when_type, case_arm_location(node, when_node, when_type)), 0]
         end
         arms[build_tuple(:else, else_arm_location(node))] = 0
         @branches[build_tuple(:case, node.location)] = arms
       end
 
-      # Resolve the source range Coverage attributes to a synthetic-or-real
-      # `:else` arm of a case construct: the body of an explicit else,
-      # or the case's full range when no else is present.
-      def else_arm_location(node)
-        return node.location unless node.else_clause
-
-        arm_location(else_body_of(node.else_clause), node.else_clause.location)
-      end
-
       def emit_loop(node, type)
         cond_tuple = build_tuple(type, node.location)
-        body_loc = arm_location(node.statements, node.location)
-        @branches[cond_tuple] = {build_tuple(:body, body_loc) => 0}
+        @branches[cond_tuple] = {build_tuple(:body, loop_body_location(node)) => 0}
       end
 
-      # Body location for an arm. Prism's `statements` is a StatementsNode
-      # whose span covers the contained expressions; fall back to the
-      # parent when the arm body is empty (e.g., `if cond then end`).
-      def arm_location(statements, fallback_location)
-        statements&.location || fallback_location
-      end
-
-      # simplecov:disable branch
-      # The `else_node` fallback is defensive: every Prism node passed
-      # in here in practice responds to `:statements`.
-      def else_body_of(else_node)
-        else_node.respond_to?(:statements) ? else_node.statements : else_node
-      end
-      # simplecov:enable branch
-
       def build_tuple(type, location)
         id = @next_id
         @next_id += 1

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.0"
+  VERSION = "1.1.1"
 end

data/lib/simplecov.rb

@@ -8,14 +8,18 @@ module SimpleCov
   # every coverage criterion has been disabled.
   class ConfigurationError < StandardError; end
 
-  class << self
-    CRITERION_TO_RUBY_COVERAGE = {
-      branch: :branches,
-      line: :lines,
-      method: :methods,
-      oneshot_line: :oneshot_lines
-    }.freeze
+  # Maps SimpleCov's criterion names to the keys `Coverage.start` expects.
+  # Lives at module scope (not inside `class << self`) so it can be
+  # declared in the RBS signatures; lexical scoping keeps every existing
+  # reference inside the singleton class working.
+  CRITERION_TO_RUBY_COVERAGE = {
+    branch: :branches,
+    line: :lines,
+    method: :methods,
+    oneshot_line: :oneshot_lines
+  }.freeze
 
+  class << self
     attr_accessor :pid
     # When this process started tracking coverage. Captured by SimpleCov.start
     # so JSONFormatter can detect when an existing coverage.json was written
@@ -93,10 +97,13 @@ module SimpleCov
     # the warning is the cue to move `SimpleCov.start` into a test helper.
     # See #581.
     def with_dot_simplecov_autoload
-      previous = @autoloading_dot_simplecov
+      # Read in the ensure clause, where flow analysis cannot see the
+      # assignment above; anchor the type here.
+      previous = @autoloading_dot_simplecov # : bool?
       @autoloading_dot_simplecov = true
       yield
     ensure
+      # @type var previous: bool?
       @autoloading_dot_simplecov = previous
     end
 
@@ -123,7 +130,11 @@ module SimpleCov
       return if @at_exit_hook_installed
 
       @at_exit_hook_installed = true
-      defer_to_minitest_after_run if minitest_autorun_pending?
+      # Never defer in a forked child: Minitest pins its after_run at_exit
+      # to the pid that armed autorun, so the deferral target can't fire
+      # there and the child's resultset would be silently dropped. See
+      # issue #1227.
+      defer_to_minitest_after_run if minitest_autorun_pending? && !forked_subprocess?
       Kernel.at_exit do
         next if SimpleCov.external_at_exit?
 
@@ -147,10 +158,8 @@ module SimpleCov
                                               ::Process.respond_to?(:_fork)
       # simplecov:enable
 
-      # Trigger adapter selection now so the (possibly lazy) parallel_tests
-      # gem load happens at start_tracking time rather than mid-suite.
-      # `current` is memoized; subsequent calls are cheap.
-      SimpleCov::ParallelAdapters.current
+      # Select the parallel adapter and generate identities before any forks.
+      SimpleCov::RunIdentity.prepare
 
       @result = nil
       self.pid = Process.pid
@@ -173,7 +182,7 @@ module SimpleCov
 
       start_arguments[:eval] = true if coverage_for_eval_enabled?
 
-      Coverage.start(start_arguments) unless Coverage.running?
+      Coverage.start(**start_arguments) unless Coverage.running?
     end
 
     # `Rake::TestTask` runs `ruby -e 'require "minitest/autorun"; ...'`,
@@ -203,7 +212,9 @@ module SimpleCov
       return unless defined?(JRUBY_VERSION) && defined?(JRuby) # simplecov:disable — JRuby-only branch
 
       # simplecov:disable — JRuby-only branches; unreachable from CRuby
-      return if org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED
+      # `org` is JRuby's Java-package entry point; it does not exist on
+      # CRuby, so no RBS declaration can be truthful here.
+      return if org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED # steep:ignore NoMethod
 
       warn 'Coverage may be inaccurate; set the "--debug" command line option, ' \
            'or do JRUBY_OPTS="--debug" ' \
@@ -217,6 +228,7 @@ end
 require "forwardable"
 require_relative "simplecov/color"
 require_relative "simplecov/deprecation"
+require_relative "simplecov/group_names"
 require_relative "simplecov/configuration"
 SimpleCov.extend SimpleCov::Configuration
 require_relative "simplecov/coverage_statistics"
@@ -232,24 +244,32 @@ require_relative "simplecov/result"
 require_relative "simplecov/filter"
 require_relative "simplecov/formatter"
 require_relative "simplecov/last_run"
+require_relative "simplecov/report_stamp"
 require_relative "simplecov/lines_classifier"
 require_relative "simplecov/result_merger"
+require_relative "simplecov/parallel_result_merger"
 require_relative "simplecov/parallel_adapters"
+require_relative "simplecov/run_identity"
+SimpleCov.extend SimpleCov::RunIdentity::Accessors
 require_relative "simplecov/command_guesser"
 require_relative "simplecov/version"
 require_relative "simplecov/result_adapter"
 require_relative "simplecov/combine"
+require_relative "simplecov/combine/identity_interner"
 require_relative "simplecov/combine/branches_combiner"
 require_relative "simplecov/combine/methods_combiner"
-require_relative "simplecov/combine/files_combiner"
 require_relative "simplecov/combine/lines_combiner"
+require_relative "simplecov/combine/coverage_accumulator"
 require_relative "simplecov/combine/results_combiner"
 require_relative "simplecov/useless_results_remover"
 require_relative "simplecov/simulate_coverage"
+require_relative "simplecov/unloaded_file_injector"
 require_relative "simplecov/result_processing"
 require_relative "simplecov/exit_handling"
+require_relative "simplecov/report_deferral"
 require_relative "simplecov/parallel_coordination"
 
 # Load default config
-# simplecov:disable — env-var only set by aruba feature tests
+# simplecov:disable — env-var never set in the dogfooded test process
+# (sandbox fixture subprocesses set it via simplecov/no_defaults)
 require_relative "simplecov/defaults" unless ENV["SIMPLECOV_NO_DEFAULTS"]