simplecov 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26a19b5934dcf245f7e9cd50f8bc86224c4a7e8f02be43d813596d1de36e637d
-  data.tar.gz: b20bbfed696e333c5b41647b96202cf86b0a9375e529871052ecf3522cb37ae0
+  metadata.gz: 1f159cd5427690b20f11c1e4a3f1a90c23c16f5f65e2043205bf132a5abc0218
+  data.tar.gz: d5a28a2c529ff2b59652bd0c1ba1f9d649c7c24fd02521905c6d2cbe6b1eeae3
 SHA512:
-  metadata.gz: 5f97c41bad62008a68ad3fb02919be7728e1f0c1f61049ff2d47f57455ef4d86530271ad4a7f7704b022ffd44366f0c41ebe4f051631ce5d67acff7b9e31a9c2
-  data.tar.gz: 5aeb18029dcb5aafad9dc878aa218113cbe26643db1bf8a1f5b1eabe09855ba0a91605a68c874bbc11f38d969d2c972090a6888ef1692d6f8c7d8bce0124d0fb
+  metadata.gz: 792c138d327b5d305ebe273dfd5a97d70eb8104102557d5ae6452a26d5cc64e1db7720c3de5e2c556a78b22561c53778579909ddef7f4615e1c447f041fa921c
+  data.tar.gz: 9f6479ceabbd5f6fc24585a2134a0f4e1270dbd988922d4d387e5695055b811655999b3d95c2a9b31c960cf0c22aa884d5bf94eae93ca6fb97868bbec0de3aab

data/lib/simplecov/cli/coverage.rb

@@ -28,7 +28,7 @@ module SimpleCov
       end
 
       def parse(args, stderr:)
-        opts = {input: SimpleCov::CLI.default_input, json: false, no_color: false}
+        opts = {input: SimpleCov::CLI.default_input, json: false, no_color: false} #: Hash[Symbol, untyped]
         rest =
           OptionParser.new do |o|
             o.on("--input PATH") { |v| opts[:input] = v }
@@ -45,7 +45,8 @@ module SimpleCov
         return stderr.puts("simplecov coverage: #{opts[:input]} not found") && nil unless File.exist?(opts[:input])
 
         data = JSON.parse(File.read(opts[:input]))
-        match = lookup(data.fetch("coverage", {}), opts[:path])
+        none = {} #: Hash[String, untyped]
+        match = lookup(data.fetch("coverage", none), opts[:path])
         return match if match
 
         stderr.puts("simplecov coverage: no entry for #{opts[:path]} in #{opts[:input]}")
@@ -65,7 +66,8 @@ module SimpleCov
       def emit(match, opts, stdout)
         filename, payload = match
         if opts[:json]
-          stdout.puts(JSON.pretty_generate(filename => payload))
+          entry = {filename => payload} #: Hash[untyped, untyped]
+          stdout.puts(JSON.pretty_generate(entry))
         else
           print_human(filename, payload, stdout, SimpleCov::CLI.color_enabled?(opts, stdout))
         end

data/lib/simplecov/cli/diff.rb

@@ -68,7 +68,8 @@ module SimpleCov
       end
 
       def load_coverage(path, stderr)
-        return normalize_keys(JSON.parse(File.read(path)).fetch("coverage", {})) if File.exist?(path)
+        no_coverage = {} #: Hash[String, untyped]
+        return normalize_keys(JSON.parse(File.read(path)).fetch("coverage", no_coverage)) if File.exist?(path)
 
         stderr.puts("simplecov diff: #{path} not found")
         nil

data/lib/simplecov/cli/dotfile.rb

@@ -57,8 +57,8 @@ module SimpleCov
       end
 
       def with_simplecov_loaded
-        previous_no_defaults = ENV.fetch("SIMPLECOV_NO_DEFAULTS", nil)
-        previous_cli         = ENV.fetch("SIMPLECOV_CLI", nil)
+        previous_no_defaults = ENV.fetch("SIMPLECOV_NO_DEFAULTS", nil) #: String?
+        previous_cli         = ENV.fetch("SIMPLECOV_CLI", nil) #: String?
         ENV["SIMPLECOV_NO_DEFAULTS"] = "1"
         # SIMPLECOV_CLI lets a project's `.simplecov` opt some config into
         # CLI-only behavior — e.g. simplecov itself sets `coverage_dir`
@@ -67,6 +67,8 @@ module SimpleCov
         require "simplecov"
         yield
       ensure
+        # @type var previous_no_defaults: String?
+        # @type var previous_cli: String?
         ENV["SIMPLECOV_NO_DEFAULTS"] = previous_no_defaults
         ENV["SIMPLECOV_CLI"]         = previous_cli
       end
@@ -79,20 +81,23 @@ module SimpleCov
       def load_with_start_neutered(path)
         klass = SimpleCov.singleton_class
         names = %i[start_tracking install_at_exit_hook]
-        stash = names.to_h { |name| [name, klass.instance_method(name)] }
+        stash = names.to_h { |name| [name, klass.instance_method(name)] } #: Hash[Symbol, UnboundMethod]
         # define_method over an existing method emits a "method redefined"
         # warning under $VERBOSE; the override and restore are intentional.
         silence_verbose { names.each { |name| klass.define_method(name) { nil } } }
         load path
       ensure
+        # @type var stash: Hash[Symbol, UnboundMethod]
+        # @type var klass: Class
         silence_verbose { stash.each { |name, method| klass.define_method(name, method) } }
       end
 
       def silence_verbose
-        previous = $VERBOSE
+        previous = $VERBOSE #: bool?
         $VERBOSE = nil
         yield
       ensure
+        # @type var previous: bool?
         $VERBOSE = previous
       end
     end

data/lib/simplecov/cli/merge.rb

@@ -57,7 +57,8 @@ module SimpleCov
       # generic "no mergeable results" into a message that points at
       # the specific input causing the failure.
       def parse_inputs(files, stderr)
-        files.each_with_object({}) do |path, memo|
+        parsed = {} #: Hash[String, Hash[String, untyped]]
+        files.each_with_object(parsed) do |path, memo|
           data = parse_input(path, stderr) or return nil
 
           memo[path] = data
@@ -85,8 +86,9 @@ module SimpleCov
       # mistake for "no merge happened." Surface the overlap so the
       # operator can rename the workers or accept the merge knowingly.
       def warn_about_duplicate_command_names(parsed, stderr)
-        files_per_command = parsed.each_with_object({}) do |(path, data), memo|
-          data.each_key { |command_name| (memo[command_name] ||= []) << path }
+        files_per_command = {} #: Hash[String, Array[String]]
+        parsed.each do |path, data|
+          data.each_key { |command_name| (files_per_command[command_name] ||= []) << path }
         end
         files_per_command.each do |command_name, paths|
           next if paths.size < 2

data/lib/simplecov/cli/report.rb

@@ -45,8 +45,9 @@ module SimpleCov
       end
 
       def emit_text(stdout, data, color)
-        emit_totals(stdout, "All Files", data.fetch("total", {}), color)
-        data.fetch("groups", {}).each { |name, group| emit_totals(stdout, name, group, color) }
+        none = {} #: Hash[String, untyped]
+        emit_totals(stdout, "All Files", data.fetch("total", none), color)
+        data.fetch("groups", none).each { |name, group| emit_totals(stdout, name, group, color) }
       end
 
       def emit_totals(stdout, label, totals, color)
@@ -66,17 +67,21 @@ module SimpleCov
       end
 
       def emit_json(stdout, data)
-        payload = {"All Files" => collect_section(data.fetch("total", {}))}
-        data.fetch("groups", {}).each { |name, group| payload[name] = collect_section(group) }
+        none = {} #: Hash[String, untyped]
+        payload = {"All Files" => collect_section(data.fetch("total", none))}
+        data.fetch("groups", none).each { |name, group| payload[name] = collect_section(group) }
         stdout.puts(JSON.pretty_generate(payload))
       end
 
       def collect_section(totals)
-        SECTIONS.each_with_object({}) do |(_, key), out|
+        sections = {} #: Hash[String, untyped]
+        SECTIONS.each_with_object(sections) do |(_, key), out|
           section = totals[key]
           next unless section.is_a?(Hash) && section["total"].to_i.positive?
 
-          out[key] = {"percent" => section["percent"], "covered" => section["covered"], "total" => section["total"]}
+          out[key.to_s] = {
+            "percent" => section["percent"], "covered" => section["covered"], "total" => section["total"]
+          }
         end
       end
     end

data/lib/simplecov/cli/run.rb

@@ -8,7 +8,7 @@ module SimpleCov
     # without a test_helper that already calls SimpleCov.start (e.g.
     # plain `bundle exec rake test` on an unconfigured library).
     module Run
-      AUTOSTART = File.expand_path("../autostart", __dir__)
+      AUTOSTART = File.expand_path("../autostart", __dir__.to_s)
 
     module_function
 

data/lib/simplecov/cli/serve.rb

@@ -36,16 +36,26 @@ module SimpleCov
         return error(stderr, "#{dir} doesn't exist; run your test suite first") unless File.directory?(dir)
 
         require "socket"
-        server = TCPServer.new(opts[:host], opts[:port])
-        announce(stdout, server, dir)
-        serve_loop(server, dir, stdout)
-        0
-      ensure
-        server&.close
+        with_server(opts) do |server|
+          announce(stdout, server, dir)
+          serve_loop(server, dir, stdout)
+          0
+        end
+      end
+
+      def with_server(opts)
+        # The receiver cast works around an rbs stdlib gap: TCPSocket's
+        # explicit `self.new` shadows TCPServer#initialize's (host, port) form.
+        server = (_ = TCPServer).new(opts[:host], opts[:port]) #: TCPServer
+        begin
+          yield server
+        ensure
+          server.close
+        end
       end
 
       def parse(args)
-        opts = {port: 0, host: "127.0.0.1"}
+        opts = {port: 0, host: "127.0.0.1"} #: Hash[Symbol, untyped]
         OptionParser.new do |o|
           o.on("--port N", Integer) { |v| opts[:port] = v }
           o.on("--host HOST")       { |v| opts[:host] = v }

data/lib/simplecov/cli/uncovered.rb

@@ -33,7 +33,8 @@ module SimpleCov
       def report(opts, keys, stdout, stderr)
         return 1 unless (data = Report.load_data(opts[:input], stderr))
 
-        files = rank(data.fetch("coverage", {}), opts[:threshold], keys).first(opts[:top])
+        none = {} #: Hash[String, untyped]
+        files = rank(data.fetch("coverage", none), opts[:threshold], keys).first(opts[:top])
         return stdout.puts(empty_message(opts[:json])) || 0 if files.empty?
 
         emit(stdout, files, opts)

data/lib/simplecov/color.rb

@@ -34,7 +34,12 @@ module SimpleCov
     # doesn't get ANSI sequences. See the module-level comment for
     # precedence.
     def enabled?(stream = $stderr)
-      config = SimpleCov.color
+      # `SimpleCov.color` only exists once the full library is loaded.
+      # The standalone CLI (`exe/simplecov`) loads `simplecov/color`
+      # without `simplecov` itself to stay lightweight, so treat a
+      # missing config the same as its `:auto` default: fall through to
+      # the env vars and tty check below.
+      config = SimpleCov.color if SimpleCov.respond_to?(:color)
       return config if [true, false].include?(config)
       return false if env_set?("NO_COLOR")
       return true  if env_set?("FORCE_COLOR")

data/lib/simplecov/combine/branches_combiner.rb

@@ -24,7 +24,8 @@ module SimpleCov
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
-        combined = [coverage_a, coverage_b].each_with_object({}) do |coverage, memo|
+        merged = {} #: Hash[untyped, [untyped, Hash[untyped, untyped]]]
+        combined = [coverage_a, coverage_b].each_with_object(merged) do |coverage, memo|
           coverage.each do |condition, branches_inside|
             condition_key = tuple_identity(condition)
             condition_tuple, merged_branches = memo[condition_key] ||= [condition, {}]

data/lib/simplecov/combine/files_combiner.rb

@@ -9,22 +9,62 @@ module SimpleCov
     module FilesCombiner
     module_function
 
+      empty_table = {} #: Hash[untyped, untyped]
+      EMPTY_TABLE = empty_table.freeze
+      private_constant :EMPTY_TABLE
+
+      # Branch/method tuples drawn from a simulated (never-loaded) file
+      # when the other side of the merge was actually executed.
+      NO_SYNTHESIZED = {"branches" => EMPTY_TABLE, "methods" => EMPTY_TABLE}.freeze
+
       #
       # Combines the results for 2 coverages of a file.
       #
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
+        source_a, source_b = reconcile_synthesized(coverage_a, coverage_b)
+
         combination = {"lines" => Combine.combine(LinesCombiner, coverage_a["lines"], coverage_b["lines"])}
         if SimpleCov.branch_coverage?
-          combined_branches = Combine.combine(BranchesCombiner, coverage_a["branches"], coverage_b["branches"])
+          combined_branches = Combine.combine(BranchesCombiner, source_a["branches"], source_b["branches"])
           combination["branches"] = combined_branches || {}
         end
         if SimpleCov.method_coverage?
-          combination["methods"] = Combine.combine(MethodsCombiner, coverage_a["methods"], coverage_b["methods"])
+          combination["methods"] = Combine.combine(MethodsCombiner, source_a["methods"], source_b["methods"])
         end
         combination
       end
+
+      # When exactly one side of the merge was actually executed, its branch
+      # and method tuples are authoritative and the other side's are dropped.
+      # A simulated entry (SimulateCoverage backfills tracked-but-unloaded
+      # files) synthesizes those tuples statically, so a location that drifts
+      # from what Coverage emits would otherwise be unioned in by position
+      # and survive as a phantom, permanently-missed branch (see #1233). This
+      # contains any such drift to denominator inflation for files no process
+      # loaded, rather than a false miss on a covered file. Lines are never
+      # dropped: a simulated file's line shape is correct and carries the
+      # unloaded-file denominator (#1059).
+      #
+      # Returns the two coverages to draw branch/method tuples from, blanking
+      # the non-executed side only when the other side was executed. When
+      # both sides were executed (two real runs) or neither was (all
+      # simulated), both are returned unchanged and combine normally.
+      def reconcile_synthesized(coverage_a, coverage_b)
+        executed_a = executed?(coverage_a)
+        executed_b = executed?(coverage_b)
+        return [coverage_a, coverage_b] if executed_a == executed_b
+
+        executed_a ? [coverage_a, NO_SYNTHESIZED] : [NO_SYNTHESIZED, coverage_b]
+      end
+
+      # A file some process actually loaded has at least one executed line;
+      # a simulated (never-loaded) file's lines are all `nil` or `0`.
+      def executed?(coverage)
+        lines = Array(coverage["lines"]) #: Array[Integer?]
+        lines.any? { |count| count&.positive? }
+      end
     end
   end
 end

data/lib/simplecov/combine/methods_combiner.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../source_file/ruby_data_parser"
+
 module SimpleCov
   module Combine
     #
@@ -12,14 +14,35 @@ module SimpleCov
       #
       # Return merged methods or the existing methods if other is missing.
       #
-      # Method coverage is a flat hash mapping method identifiers to hit counts.
-      # Combining sums the hit counts for matching methods and preserves methods
-      # that only appear in one result.
+      # Method coverage maps `[class, name, start_line, start_col, end_line,
+      # end_col]` keys to hit counts. Keys are matched on their SOURCE
+      # identity — (name, location), ignoring the class element — because
+      # Ruby records one entry per receiver: the same `define_method` block
+      # defined onto different classes in different processes arrives with
+      # different (normalized) receivers for the same source method, and
+      # matching on the full key would keep both, letting a never-called
+      # receiver's 0 shadow a covered method after merge (issue #1234).
+      # Combining sums the hit counts for matching methods and preserves
+      # methods that only appear in one result.
       #
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
-        coverage_a.merge(coverage_b) { |_key, a_count, b_count| a_count + b_count }
+        merged = {} #: Hash[untyped, [untyped, Integer]]
+        [coverage_a, coverage_b].each_with_object(merged) do |coverage, memo|
+          coverage.each do |key, count|
+            method_key = source_identity(key)
+            retained_key, existing = memo[method_key] || [key, 0]
+            memo[method_key] = [retained_key, existing + count]
+          end
+        end
+
+        merged.values.to_h
+      end
+
+      def source_identity(key)
+        _class_name, *identity = SourceFile::RubyDataParser.call(key)
+        identity
       end
     end
   end

data/lib/simplecov/combine/results_combiner.rb

@@ -21,7 +21,8 @@ module SimpleCov
       # @return [Hash]
       #
       def combine(*results)
-        results.reduce({}) do |combined_results, next_result|
+        initial = {} #: Hash[untyped, untyped]
+        results.reduce(initial) do |combined_results, next_result|
           combine_result_sets(combined_results, next_result)
         end
       end

data/lib/simplecov/configuration/coverage.rb

@@ -42,7 +42,9 @@ module SimpleCov
     #
     def coverage(criterion, primary: false, enabled: true, oneshot: false, **thresholds, &block)
       criterion = enable_coverage_criterion(criterion, enabled: enabled, oneshot: oneshot)
-      primary_coverage(criterion) if primary
+      # The cast admits :eval, which primary_coverage rejects at runtime
+      # (it is enable-only and never in the enabled-criteria set).
+      primary_coverage(_ = criterion) if primary
 
       configurator = CoverageCriterion.new(self, criterion)
       apply_threshold_options(configurator, thresholds)
@@ -164,7 +166,9 @@ module SimpleCov
 
       # Make this criterion the report's primary (leading) criterion.
       def primary
-        @config.primary_coverage(@criterion)
+        # @criterion is Symbol-wide because this receiver is also built for
+        # :eval; primary_coverage validates at runtime.
+        @config.primary_coverage(_ = @criterion)
       end
     end
   end

data/lib/simplecov/configuration/coverage_criteria.rb

@@ -134,7 +134,9 @@ module SimpleCov
     def default_primary_coverage
       return DEFAULT_COVERAGE_CRITERION if coverage_criterion_enabled?(DEFAULT_COVERAGE_CRITERION)
 
-      coverage_criteria.first
+      # Set#first types as nilable, but an empty criteria set is rejected at
+      # start_tracking before any caller can observe a nil here.
+      _ = coverage_criteria.first
     end
 
     def raise_if_criterion_disabled(criterion)

data/lib/simplecov/configuration/formatting.rb

@@ -17,22 +17,32 @@ module SimpleCov
     # overhead.
     #
     def formatter(formatter = :__no_arg__)
-      return @formatter if formatter == :__no_arg__
-
-      @formatter = formatter || nil # normalize `false` to `nil`
+      case formatter
+      when :__no_arg__
+        @formatter
+      else
+        @formatter = formatter || nil # normalize `false` to `nil`
+      end
     end
 
     # Sets the configured formatters. Pass `[]` to opt out of
     # formatting entirely; see `formatter` for the rationale.
     def formatters(formatters = :__no_arg__)
-      return Array(formatter) if formatters == :__no_arg__
-
-      self.formatters = formatters
-      formatters
+      case formatters
+      when :__no_arg__
+        configured = formatter
+        configured ? [configured] : []
+      else
+        self.formatters = formatters
+        formatters
+      end
     end
 
     # Sets the configured formatters. Equivalent to `formatters [...]`.
+    # Accepts a single formatter as well as an Array, matching the pre-1.0 behavior
+    # where `MultiFormatter.new` normalized its input.
     def formatters=(formatters)
+      formatters = Array(formatters)
       @formatter = formatters.empty? ? nil : SimpleCov::Formatter::MultiFormatter.new(formatters)
     end
 

data/lib/simplecov/configuration/thresholds.rb

@@ -123,7 +123,11 @@ module SimpleCov
     # so downstream code only has one shape to handle.
     def partition_per_file_thresholds(coverage)
       coverage.each_key { |key| validate_per_file_key(key) }
-      defaults, raw = coverage.partition { |key, _| key.is_a?(Symbol) }.map(&:to_h)
+      pairs = coverage.partition { |key, _| key.is_a?(Symbol) }
+      # The assertions restate what the partition predicate guarantees:
+      # Symbol keys carry per-criterion Numeric defaults, the rest are paths.
+      defaults = pairs[0].to_h #: coverage_thresholds
+      raw = pairs[1].to_h #: Hash[String | Regexp, Numeric | coverage_thresholds]
       overrides = raw.transform_values { |value| value.is_a?(Numeric) ? {primary_coverage => value} : value }
       [defaults, overrides]
     end
@@ -143,11 +147,11 @@ module SimpleCov
     # `minimum_coverage_by_file` argument so the deprecation warning can be
     # copy-pasted verbatim into the user's config.
     def per_file_coverage_replacement(defaults, overrides)
-      by_criterion = Hash.new { |hash, criterion| hash[criterion] = [] }
-      defaults.each { |criterion, percent| by_criterion[criterion] << "minimum_per_file #{percent}" }
+      by_criterion = {} #: Hash[Symbol, Array[String]]
+      defaults.each { |criterion, percent| (by_criterion[criterion] ||= []) << "minimum_per_file #{percent}" }
       overrides.each do |target, criteria|
         criteria.each do |criterion, percent|
-          by_criterion[criterion] << "minimum_per_file #{percent}, only: #{target.inspect}"
+          (by_criterion[criterion] ||= []) << "minimum_per_file #{percent}, only: #{target.inspect}"
         end
       end
       render_coverage_blocks(by_criterion)
@@ -155,11 +159,11 @@ module SimpleCov
 
     # Same, for a (deprecated) `minimum_coverage_by_group` argument.
     def per_group_coverage_replacement(coverage)
-      by_criterion = Hash.new { |hash, criterion| hash[criterion] = [] }
-      coverage.each do |group_name, group_coverage|
-        group_coverage = {primary_coverage => group_coverage} if group_coverage.is_a?(Numeric)
-        group_coverage.each do |criterion, percent|
-          by_criterion[criterion] << "minimum_per_group #{percent}, only: #{group_name.inspect}"
+      by_criterion = {} #: Hash[Symbol, Array[String]]
+      coverage.each do |group_name, thresholds|
+        normalized = (thresholds.is_a?(Numeric) ? {primary_coverage => thresholds} : thresholds) #: coverage_thresholds
+        normalized.each do |criterion, percent|
+          (by_criterion[criterion] ||= []) << "minimum_per_group #{percent}, only: #{group_name.inspect}"
         end
       end
       render_coverage_blocks(by_criterion)

data/lib/simplecov/configuration.rb

@@ -51,9 +51,10 @@ module SimpleCov
     #
     def coverage_path(path = nil)
       if path
-        @coverage_path = File.expand_path(path)
+        expanded = File.expand_path(path)
+        @coverage_path = expanded
         @coverage_path_explicit = true
-        FileUtils.mkdir_p @coverage_path
+        FileUtils.mkdir_p expanded
       end
 
       @coverage_path ||= File.expand_path(coverage_dir, root)
@@ -65,9 +66,8 @@ module SimpleCov
     # with SimpleCov.command_name("test:units").
     #
     def command_name(name = nil)
-      @name = name unless name.nil?
-      @name ||= SimpleCov::CommandGuesser.guess
-      @name
+      @command_name = name unless name.nil?
+      @command_name ||= SimpleCov::CommandGuesser.guess
     end
 
     # Returns the hash of available profiles
@@ -80,17 +80,24 @@ module SimpleCov
     # prepending SimpleCov to each config method.
     #
     def configure(&block)
-      block_context = block.binding.receiver
+      # Both locals are read in the ensure clause, where flow analysis
+      # cannot see the assignments below; anchor their types up front.
+      saved = nil # : Hash[Symbol, untyped]?
+      block_context = block.binding.receiver # : untyped
 
-      # If the block was defined in our own context, instance_exec is sufficient
-      return instance_exec(&block) if equal?(block_context)
+      # If the block was defined in our own context, instance_exec is
+      # sufficient. The `_ =` erases the block's self-binding, which RBS
+      # can express but `instance_exec`'s core signature cannot accept.
+      return instance_exec(&(_ = block)) if equal?(block_context)
 
       # Copy the caller's instance variables in so that references like @filter
       # inside the block resolve to the caller's values, not ours.
       saved = swap_ivars_from(block_context)
-      instance_exec(&block)
+      instance_exec(&(_ = block))
     ensure
-      restore_ivars(block_context, saved) if defined?(saved) && saved
+      # @type var block_context: untyped
+      # @type var saved: Hash[Symbol, untyped]?
+      restore_ivars(block_context, saved) if saved
     end
 
     #
@@ -100,7 +107,8 @@ module SimpleCov
     #
     def at_exit(&block)
       @at_exit = block if block
-      return @at_exit if @at_exit
+      configured = @at_exit
+      return configured if configured
       return proc {} unless active_session?
 
       @at_exit = proc do
@@ -144,7 +152,8 @@ module SimpleCov
     # SimpleCov.root, capitalized with underscores → spaces.
     #
     def project_name(new_name = nil)
-      return @project_name if defined?(@project_name) && @project_name && new_name.nil?
+      current = defined?(@project_name) ? @project_name : nil
+      return current if current && new_name.nil?
 
       @project_name = new_name if new_name.is_a?(String)
       @project_name ||= File.basename(root).capitalize.tr("_", " ")
@@ -156,7 +165,7 @@ module SimpleCov
     # of ours that would be clobbered. Returns the saved values for
     # later restoration.
     def swap_ivars_from(block_context)
-      saved = {}
+      saved = {} # : Hash[Symbol, untyped]
       our_ivars = instance_variables
       block_context.instance_variables.each do |ivar|
         saved[ivar] = instance_variable_get(ivar) if our_ivars.include?(ivar)

data/lib/simplecov/coverage_statistics.rb

@@ -14,9 +14,12 @@ module SimpleCov
   class CoverageStatistics
     attr_reader :total, :covered, :missed, :omitted, :strength, :percent
 
+    # Seed for the reduce in `.from`: covered, missed, omitted, strength.
+    ZERO_STATS = [0, 0, 0, 0.0].freeze #: [Integer, Integer, Integer, Float]
+
     def self.from(coverage_statistics)
       sum_covered, sum_missed, sum_omitted, sum_total_strength =
-        coverage_statistics.reduce([0, 0, 0, 0.0]) do |(covered, missed, omitted, total_strength), stats|
+        coverage_statistics.reduce(ZERO_STATS) do |(covered, missed, omitted, total_strength), stats|
           [
             covered + stats.covered,
             missed + stats.missed,

data/lib/simplecov/coverage_violations.rb

@@ -46,7 +46,8 @@ module SimpleCov
       def minimum_by_group(result, thresholds)
         thresholds.flat_map do |group_name, minimums|
           group = lookup_group(result, group_name)
-          group ? group_minimum_violations(group_name, group, minimums) : []
+          none = [] # : Array[Hash[Symbol, untyped]]
+          group ? group_minimum_violations(group_name, group, minimums) : none
         end
       end
 

data/lib/simplecov/defaults.rb

@@ -41,12 +41,12 @@ loop do
     # it are intercepted and converted to configuration, with a deprecation
     # warning. See `SimpleCov.with_dot_simplecov_autoload` and issue #581.
     SimpleCov.with_dot_simplecov_autoload do
-      load filename
-    rescue LoadError, StandardError
+      load filename.to_s
+    rescue LoadError, StandardError => e
       # simplecov:disable — only fires when .simplecov is unreadable
       # or raises during load
       warn "Warning: Error occurred while trying to load #{filename}. " \
-           "Error message: #{$ERROR_INFO.message}"
+           "Error message: #{e.message}"
       # simplecov:enable
     end
     break

data/lib/simplecov/directive.rb

@@ -55,8 +55,11 @@ module SimpleCov
     # An unclosed `disable` block extends to the end of the file.
     def self.disabled_ranges(src_lines)
       lines = src_lines.to_a
-      ranges = CATEGORIES.to_h { |category| [category, []] }
-      open_starts = {}
+      ranges = CATEGORIES.to_h do |category|
+        empty = [] # : Array[Range[Integer]]
+        [category, empty]
+      end
+      open_starts = {} # : Hash[Symbol, Integer]
 
       directives_in(lines).each { |directive| directive.apply(ranges, open_starts) }
       open_starts.each { |category, start| ranges[category] << (start..lines.size) }
@@ -91,7 +94,9 @@ module SimpleCov
 
       new(
         line_number: line_number,
-        mode: match[:mode].to_sym,
+        # `to_s` is a no-op: the pattern requires the `mode` group, so it
+        # is present whenever `match` is; it also satisfies the type checker.
+        mode: match[:mode].to_s.to_sym,
         categories: parse_categories(match[:categories]),
         inline: inline?(lines, line_number, column + match.begin(0))
       )