simplecov-sorbet 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 769829fc88734ccfb203a5472a779e267ba07dac55d6fd6099955fd9de090740
-  data.tar.gz: a948a59b02a9e94812f85ebdce285629d4b665617209df09b20641069498ac94
+  metadata.gz: 73744e2677661e69504801208d5e5e99224532de82e6ba71c62f8cd10df75aed
+  data.tar.gz: ca8f0945384722715fb35b473f64d80083b4a8d00e4240c4e5796f7bedc33384
 SHA512:
-  metadata.gz: 577b36bd437cacde42b28a22b17d480b7983cfd6ab88c93ed14a955dc79656e650d8cf233a539c173e87a1277fa9681b4855a0128755c4464b2c58e0bfe36c0c
-  data.tar.gz: fea6c1ed8d99d3d66111bcaad5369e77867321025b16730b0b12e4e6c2d374f8c288db3eb8a0264fe019622e352c981f99db3361164b02a14266234cd4e5f62f
+  metadata.gz: b6695fce11be79e42e782781912385748a65a374427e5484ba8c7250ad97589d10a3a18a89c494bd9858cb15cc9b5f569702c4e02af0266001a338d9420f6d06
+  data.tar.gz: 1e2a853a3fb0da0a5a693a5f8ae88d76705e12d498504fbbd2a83465fa2c2f69df535fcdf03135d549be25d7603011e5bccdcb83d28b5b80c2507764f0faded4

data/.rubocop.yml

@@ -1,11 +1,19 @@
 inherit_gem:
   rubocop-shopify: rubocop.yml
 
+inherit_mode:
+  merge:
+    - Exclude
+
 plugins:
   - rubocop-sorbet
 
 AllCops:
   SuggestExtensions: false
+  Exclude:
+    # Polyglot sh/ruby bootstrap scripts (#!/bin/sh preamble re-execing via
+    # `ruby -x`); not parseable as plain Ruby.
+    - bin/**/*
 
 # Tests are written in the RSpock dialect: bare comparisons in Then/Expect
 # blocks and block-name constants (Given/When/Then/Where/Cleanup) are

data/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-07-29
+### Added
+- `sig` block skipping: all multi-line `sig` blocks (bare or with a receiver, e.g. `T::Sig::WithoutRuntime.sig`) are excluded from coverage. Sigs are type metadata whose correctness `srb tc` owns; an untested method still reports its body as the miss.
+- `T.absurd` send skipping: exhaustiveness checks are unreachable by definition when the code is correct, so their lines no longer read as permanent misses.
+
+### Changed
+- `TypeAliasRanges` is now `IgnoredRanges`, one analysis pass collecting all three construct kinds.
+
 ## [0.1.0] - 2026-07-29
 ### Initial release
 - `T.type_alias` block skipping: requiring `simplecov/sorbet` prepends an extension onto `SimpleCov::Directive.disabled_ranges` that parses each covered file (Prism via ast_transform's analysis API) and appends every alias block's line range to all three directive categories. Multi-line alias bodies are runtime-unreachable by design and no longer read as coverage misses.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simplecov-sorbet (0.1.0)
+    simplecov-sorbet (0.2.0)
       ast_transform (~> 3.1)
       simplecov (~> 1.0)
       sorbet-runtime
@@ -179,7 +179,7 @@ CHECKSUMS
   rubydex (0.3.0-x86_64-darwin) sha256=59d20c98b0bf2226f5db5bee14cf57075aa93aa0c3fa0176f496a217691ff7b6
   rubydex (0.3.0-x86_64-linux) sha256=dfe4026591f226b4a1b53f82f86dc14fad2e7c221ee8a5be99a0a46bf2d58b04
   simplecov (1.0.3) sha256=38ef0514f16ae7562f0d0f4df02610071115103d301b6de7dacbcc000082e39b
-  simplecov-sorbet (0.1.0)
+  simplecov-sorbet (0.2.0)
   sorbet (0.6.13367) sha256=099d9f5f420e09606deb84c9110f352e1caa970eabc01978c55dc6eb089858ce
   sorbet-runtime (0.6.13367) sha256=4891cafce050f32f0e03f593a63cfa2ed535e541633b75a035ed36fb1b067d42
   sorbet-static (0.6.13367-aarch64-linux) sha256=46416a8ed47e5c12d129a6f6418a98d2bb56d8ebeaea6d6a6a47306b4307acc5

data/README.md

@@ -1,8 +1,13 @@
+[![CI](https://github.com/d3mlabs/simplecov-sorbet/actions/workflows/ci.yml/badge.svg)](https://github.com/d3mlabs/simplecov-sorbet/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/d3mlabs/simplecov-sorbet/branch/main/graph/badge.svg)](https://codecov.io/gh/d3mlabs/simplecov-sorbet)
+
 # SimpleCov::Sorbet
 
-A [SimpleCov](https://github.com/simplecov-ruby/simplecov) extension for [Sorbet](https://sorbet.org) codebases: it skips constructs Sorbet makes runtime-unreachable by design, so they stop reading as coverage misses.
+A [SimpleCov](https://github.com/simplecov-ruby/simplecov) extension for [Sorbet](https://sorbet.org) codebases: it skips type-level Sorbet constructs that coverage should not measure, so they stop reading as coverage misses.
+
+Three constructs are skipped:
 
-Today that means multi-line `T.type_alias` blocks. sorbet-runtime resolves aliases lazily and collection checks are shallow, so the block body of
+- **Multi-line `T.type_alias` blocks.** sorbet-runtime resolves aliases lazily and collection checks are shallow, so the block body of
 
 ```ruby
 ResolvedSegment = T.type_alias do
@@ -14,7 +19,13 @@ ResolvedSegment = T.type_alias do
 end
 ```
 
-never executes — and SimpleCov (and any patch-coverage gate built on it, like Codecov's) reports those lines as uncovered. The usual workarounds are cramming the alias onto one line or sprinkling `# simplecov:disable` comments; both encode a tool-compatibility fact into every file that has an alias. This gem moves that knowledge to the layer that owns it: detection is purely syntactic (a [Prism](https://github.com/ruby/prism)-backed AST pass via [ast_transform](https://github.com/rspockframework/ast-transform)), and the found ranges feed straight into SimpleCov's skip machinery.
+  never executes — and SimpleCov (and any patch-coverage gate built on it, like Codecov's) reports those lines as uncovered.
+
+- **`sig` blocks** (bare or with a receiver such as `T::Sig::WithoutRuntime.sig`). Sigs are type metadata whose correctness `srb tc` owns; coverage should measure behavior. Skipping them sharpens the signal: an untested method reports its *body* as the miss, without sig-line noise — and `T::Sig::WithoutRuntime` sigs, which never evaluate at runtime, stop being permanent false positives. Detection matches any `sig` call with a multi-line block; a non-Sorbet DSL also named `sig` would be over-matched, an accepted risk in a Sorbet codebase.
+
+- **`T.absurd` sends.** Exhaustiveness checks are unreachable by definition when the code is correct — Sorbet statically proves the `else` branch can't be taken — so in healthy code the line is a permanent miss.
+
+The usual workarounds are cramming constructs onto one line or sprinkling `# simplecov:disable` comments; both encode a tool-compatibility fact into every file. This gem moves that knowledge to the layer that owns it: detection is purely syntactic (a [Prism](https://github.com/ruby/prism)-backed AST pass via [ast_transform](https://github.com/rspockframework/ast-transform)), and the found ranges feed straight into SimpleCov's skip machinery.
 
 ## Installation
 
@@ -35,7 +46,13 @@ SimpleCov.start
 
 ## How it works
 
-Requiring `simplecov/sorbet` prepends an extension onto `SimpleCov::Directive.disabled_ranges`, the seam SimpleCov 1.0 consults for `# simplecov:disable` ranges — for both loaded files (`SourceFile`) and tracked-but-unloaded files (`LinesClassifier`). The extension parses each covered file, collects the line range of every `T.type_alias` block (including the `::T` form), and appends those ranges to all three directive categories (`line`, `branch`, `method` — the block body is runtime-unreachable, so anything inside it is skippable). Files the parser rejects contribute no ranges and are otherwise reported untouched.
+Requiring `simplecov/sorbet` prepends an extension onto `SimpleCov::Directive.disabled_ranges`, the seam SimpleCov 1.0 consults for `# simplecov:disable` ranges — for both loaded files (`SourceFile`) and tracked-but-unloaded files (`LinesClassifier`). The extension parses each covered file, collects the line range of every ignored construct (`T.type_alias` blocks including the `::T` form, multi-line `sig` blocks, and `T.absurd` sends), and appends those ranges to all three directive categories (`line`, `branch`, `method` — type-level constructs are not behavior, so anything inside them is skippable). Files the parser rejects contribute no ranges and are otherwise reported untouched.
+
+### What is deliberately not skipped
+
+Regular sig *behavior* is unaffected: sorbet-runtime evaluates a sig block lazily on the method's first call, so before this gem an uncovered sig always accompanied an uncovered method body. Skipping sigs removes the duplicate line, not the signal — the untested body still reports as a miss. One tradeoff to know about: a sig coverage miss on a *tested* method once exposed a real bug (`module_function` copies methods before the sig wrapper installs, silently disabling runtime validation). With sigs skipped, that class of bug is RuboCop's to catch (`Style/ModuleFunction: EnforcedStyle: extend_self`), not coverage's.
+
+Skips apply through SimpleCov's directive machinery, which drives its line classification; if you enable branch coverage, branches inside skipped ranges are covered by the `branch` directive category the extension also populates.
 
 ## Requirements
 
@@ -49,15 +66,14 @@ This repo is managed with d3mlabs' `dev` tool (`dev up`, `dev test`, `dev style`
 
 ## Releasing a New Version
 
-1. Update `VERSION` in `lib/simplecov/sorbet/version.rb`, run `bundle install` to regenerate `Gemfile.lock`, commit, open a PR, and merge to main
-2. Tag and push:
-   ```
-   git checkout main && git pull
-   git tag v0.1.0
-   git push origin v0.1.0
-   ```
+From a clean checkout of `main`:
+
+```
+dev release          # auto-increments the patch version (0.1.0 → 0.1.1)
+dev release 0.2.0    # explicit version
+```
 
-The [release workflow](.github/workflows/release.yml) validates that the tag matches `version.rb`, builds the gem, and publishes it to [rubygems.org](https://rubygems.org) via [Trusted Publishing](https://guides.rubygems.org/trusted-publishing/).
+The script ([bin/release.rb](bin/release.rb)) bumps `lib/simplecov/sorbet/version.rb` and `Gemfile.lock`, commits, tags `v<version>`, pushes, creates the GitHub release, and then watches the [release workflow](.github/workflows/release.yml) — which validates that the tag matches `version.rb`, builds the gem, and publishes it to [rubygems.org](https://rubygems.org) via [Trusted Publishing](https://guides.rubygems.org/trusted-publishing/) — until the publish succeeds.
 
 ## License
 

data/bin/release.rb

@@ -0,0 +1,225 @@
+#!/bin/sh
+# Use PATH ruby (rbenv) if >= 3.1, fall back to Homebrew Ruby for bootstrapping.
+if command -v ruby >/dev/null 2>&1; then
+  if ruby -e 'exit(Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.1") ? 0 : 1)' 2>/dev/null; then
+    exec ruby -x "$0" "$@"
+  fi
+fi
+if command -v brew >/dev/null 2>&1; then
+  brew_ruby="$(brew --prefix ruby 2>/dev/null)/bin/ruby"
+  if [ -x "$brew_ruby" ]; then
+    exec "$brew_ruby" -x "$0" "$@"
+  fi
+fi
+echo "release: no ruby found. Install rbenv and a Ruby version, or brew install ruby." >&2
+exit 1
+
+#!ruby
+# frozen_string_literal: true
+
+# Release a new version of simplecov-sorbet: bump version.rb + Gemfile.lock,
+# commit, tag, push, create GitHub release, then watch the tag-triggered
+# workflow publish the gem to rubygems.org via trusted publishing.
+#
+# Usage:
+#   ./bin/release.rb                 # auto-increments patch (0.1.0 → 0.1.1)
+#   ./bin/release.rb 0.2.0           # explicit version
+#   ./bin/release.rb "Release notes" # auto-increment with custom notes
+#   ./bin/release.rb --yes           # skip the confirmation (non-interactive runs)
+
+require "pathname"
+require "open3"
+
+GEM_NAME     = "simplecov-sorbet"
+GEM_ROOT     = Pathname.new(File.expand_path("..", __dir__))
+VERSION_FILE = GEM_ROOT.join("lib", "simplecov", "sorbet", "version.rb")
+GEMFILE_LOCK = GEM_ROOT.join("Gemfile.lock")
+
+def main
+  Dir.chdir(GEM_ROOT)
+  ensure_clean_tree!
+  ensure_on_main!
+
+  # --yes skips the interactive confirmation, which would otherwise hang a
+  # piped or backgrounded run waiting for input it can never receive.
+  assume_yes = !ARGV.delete("--yes").nil?
+
+  current = current_version
+  new_version, notes = parse_args(current)
+  commits = commits_since_last_tag
+
+  print_summary(current, new_version, notes, commits)
+  abort "Aborted." unless assume_yes || confirm?("Proceed?")
+  puts
+
+  step("Bumping version #{current} → #{new_version}") do
+    bump_version(current, new_version)
+  end
+
+  step("Committing and tagging v#{new_version}") do
+    commit_and_tag(new_version, notes)
+  end
+
+  step("Pushing main + tag v#{new_version}") do
+    push(new_version)
+  end
+
+  step("Creating GitHub release v#{new_version}") do
+    create_release(new_version, notes)
+  end
+
+  # The tag push triggers .github/workflows/release.yml, which publishes to
+  # rubygems.org via trusted publishing. Watch it so a failed publish (e.g.
+  # a missing trusted-publisher configuration) can't slip by silently.
+  step("Waiting for the rubygems publish workflow") do
+    watch_publish_workflow(new_version)
+  end
+
+  puts "v#{new_version} released: https://rubygems.org/gems/#{GEM_NAME}"
+end
+
+def parse_args(current)
+  case ARGV.length
+  when 0
+    [auto_increment(current), default_notes]
+  when 1
+    arg = ARGV[0]
+    if arg.match?(/\A\d+\.\d+\.\d+\z/)
+      [arg, default_notes]
+    else
+      [auto_increment(current), arg]
+    end
+  when 2
+    [ARGV[0], ARGV[1]]
+  else
+    abort "Usage: #{$PROGRAM_NAME} [version] [notes]"
+  end
+end
+
+def current_version
+  match = VERSION_FILE.read.match(/VERSION = "(\d+\.\d+\.\d+)"/)
+  abort "Could not find VERSION in #{VERSION_FILE}" unless match
+
+  match[1]
+end
+
+def auto_increment(version)
+  parts = version.split(".").map(&:to_i)
+  parts[-1] += 1
+  parts.join(".")
+end
+
+def default_notes
+  log = `git log --oneline #{latest_tag}..HEAD`.strip
+  return log unless log.empty?
+
+  "Maintenance release."
+end
+
+def latest_tag
+  `git describe --tags --abbrev=0 2>/dev/null`.strip
+end
+
+def ensure_clean_tree!
+  status = `git status --porcelain`.strip
+  return if status.empty?
+
+  abort "Working tree is not clean. Commit or stash changes first.\n#{status}"
+end
+
+def ensure_on_main!
+  branch = `git branch --show-current`.strip
+  return if branch == "main"
+
+  abort "Must be on main branch (currently on #{branch})."
+end
+
+def commits_since_last_tag
+  tag = latest_tag
+  return [] if tag.empty?
+
+  `git log --oneline #{tag}..HEAD`.strip.lines.map(&:strip)
+end
+
+def print_summary(current, new_version, notes, commits)
+  puts "Release: #{current} → #{new_version}"
+  puts "Notes: #{notes}"
+  puts
+  if commits.empty?
+    puts "Commits: (none since #{latest_tag})"
+  else
+    puts "Commits since #{latest_tag}:"
+    commits.each { |c| puts "  #{c}" }
+  end
+  puts
+  puts "Steps:"
+  puts "  1. Bump version.rb + Gemfile.lock"
+  puts "  2. Commit + tag v#{new_version}"
+  puts "  3. Push main + tag to origin"
+  puts "  4. Create GitHub release"
+  puts "  5. Watch the trusted-publishing workflow push to rubygems.org"
+  puts
+end
+
+def confirm?(question)
+  print "#{question} (y/N) "
+  ($stdin.gets || "").strip.downcase == "y"
+end
+
+# One release step, aborting the whole release when it fails so a broken push
+# can't cascade into later steps publishing state that never reached GitHub.
+def step(title)
+  puts "--- #{title}"
+  yield
+rescue StandardError => e
+  abort "Release aborted: '#{title}' failed: #{e.message}\nFix the issue, then finish the remaining steps manually."
+end
+
+def run!(*cmd)
+  out, err, status = Open3.capture3(*cmd)
+  raise "#{cmd.join(" ")} failed: #{err}" unless status.success?
+
+  out
+end
+
+def bump_version(current, new_version)
+  VERSION_FILE.write(VERSION_FILE.read.sub(%(VERSION = "#{current}"), %(VERSION = "#{new_version}")))
+
+  # The gem is a PATH source in its own Gemfile.lock, pinned in both the PATH
+  # specs block and the DEPENDENCIES section; gsub updates the pair.
+  lock = GEMFILE_LOCK.read
+  GEMFILE_LOCK.write(lock.gsub("#{GEM_NAME} (#{current})", "#{GEM_NAME} (#{new_version})"))
+end
+
+def commit_and_tag(version, notes)
+  run!("git", "add", VERSION_FILE.to_s, GEMFILE_LOCK.to_s)
+  run!("git", "commit", "-m", "Bump version to #{version}\n\n#{notes}")
+  run!("git", "tag", "v#{version}")
+end
+
+def push(version)
+  run!("git", "push", "origin", "main")
+  run!("git", "push", "origin", "v#{version}")
+end
+
+def create_release(version, notes)
+  run!("gh", "release", "create", "v#{version}",
+    "--title", "v#{version}", "--notes", notes)
+end
+
+# Find the workflow run the tag push triggered (retrying while GitHub
+# registers it) and block until it finishes, failing loudly if it failed.
+def watch_publish_workflow(version)
+  run_id = nil
+  10.times do
+    run_id = `gh run list --workflow=release.yml --branch v#{version} --limit 1 --json databaseId --jq '.[0].databaseId'`.strip
+    break unless run_id.empty?
+
+    sleep 3
+  end
+  raise "could not find the release.yml run for v#{version}" if run_id.empty?
+
+  run!("gh", "run", "watch", run_id, "--exit-status")
+end
+
+main

data/dev.yml

@@ -12,3 +12,6 @@ commands:
   typecheck:
     desc: Run Sorbet
     run: bundle exec srb tc
+  release:
+    desc: Release a new version (bump, tag, push; CI publishes to rubygems.org)
+    run: ./bin/release.rb

data/lib/simplecov/sorbet/directive_extension.rb

@@ -5,35 +5,35 @@ module SimpleCov
   module Sorbet
     # Prepended onto SimpleCov::Directive's singleton class. Directive.disabled_ranges is the one choke point both
     # SourceFile (loaded files) and LinesClassifier (tracked-but-unloaded files) consult for skip ranges, so
-    # extending its result covers every path SimpleCov classifies lines through. Alias ranges join all three
-    # categories: the block body is runtime-unreachable, so any line, branch, or method inside it is skippable.
+    # extending its result covers every path SimpleCov classifies lines through. Ignored ranges join all three
+    # categories: type-level constructs are not behavior, so any line, branch, or method inside them is skippable.
     module DirectiveExtension
       extend T::Sig
 
       sig { params(src_lines: T::Array[String]).returns(T::Hash[Symbol, T::Array[T::Range[Integer]]]) }
       def disabled_ranges(src_lines)
         ranges = T.let(super, T::Hash[Symbol, T::Array[T::Range[Integer]]])
-        alias_ranges = type_alias_ranges(src_lines.join)
-        return ranges if alias_ranges.empty?
+        sorbet_ranges = ignored_ranges(src_lines.join)
+        return ranges if sorbet_ranges.empty?
 
-        ranges.each_value { |category_ranges| category_ranges.concat(alias_ranges) }
+        ranges.each_value { |category_ranges| category_ranges.concat(sorbet_ranges) }
         ranges
       end
 
       private
 
-      # Scans +source+ for +T.type_alias+ blocks. Unparseable source yields no ranges: coverage annotation must
-      # never take down a suite's reporting, and a file Ruby executed but this parser rejects has no aliases we
-      # could trust anyway. The rescue is deliberately wide — Prism parses most broken source tolerantly, and what
-      # escapes is not Parser::SyntaxError but arbitrary errors from the whitequark builder choking on
-      # error-recovered trees (e.g. NoMethodError in join_exprs).
+      # Scans +source+ for type-level Sorbet constructs (see IgnoredRanges). Unparseable source yields no ranges:
+      # coverage annotation must never take down a suite's reporting, and a file Ruby executed but this parser
+      # rejects has no constructs we could trust anyway. The rescue is deliberately wide — Prism parses most broken
+      # source tolerantly, and what escapes is not Parser::SyntaxError but arbitrary errors from the whitequark
+      # builder choking on error-recovered trees (e.g. NoMethodError in join_exprs).
       #
       # @param source [String] The Ruby source to scan.
       #
-      # @return [Array<Range<Integer>>] One line range per alias block, in source order.
+      # @return [Array<Range<Integer>>] One line range per ignored construct, in source order.
       sig { params(source: String).returns(T::Array[T::Range[Integer]]) }
-      def type_alias_ranges(source)
-        TypeAliasRanges.new.run(source_parser.parse(source)).ranges
+      def ignored_ranges(source)
+        IgnoredRanges.new.run(source_parser.parse(source)).ranges
       rescue StandardError
         []
       end

data/lib/simplecov/sorbet/ignored_ranges.rb

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SimpleCov
+  module Sorbet
+    # Read-only analysis pass collecting the line ranges of type-level Sorbet constructs coverage should ignore.
+    # Detection is purely syntactic — this gem never loads Sorbet's type system. Three constructs are collected:
+    #
+    # - +T.type_alias+ blocks: sorbet-runtime resolves aliases lazily and collection checks are shallow, so a
+    #   multi-line alias body never executes and reads as a permanent coverage miss.
+    # - +sig+ blocks (bare or with a receiver, e.g. +T::Sig::WithoutRuntime.sig+): sigs are type metadata whose
+    #   correctness +srb tc+ owns; coverage should measure behavior. Only multi-line blocks are collected — a
+    #   single-line +sig { ... }+ occupies the send's own line, which executes at load.
+    # - +T.absurd+ sends: unreachable by definition when exhaustiveness holds, so in correct code the line is a
+    #   permanent coverage miss.
+    class IgnoredRanges < ASTTransform::AbstractAnalysis
+      extend T::Sig
+
+      # Structural patterns for the +T+ receiver (node equality ignores source locations): +T+ and its explicit
+      # top-level form +::T+.
+      T_RECEIVERS = T.let(
+        [
+          s(:const, nil, :T),
+          s(:const, s(:cbase), :T),
+        ].freeze,
+        T::Array[Parser::AST::Node],
+      )
+
+      # One line range per ignored construct, in source order.
+      sig { returns(T::Array[T::Range[Integer]]) }
+      attr_reader :ranges
+
+      sig { void }
+      def initialize
+        @ranges = T.let([], T::Array[T::Range[Integer]])
+        super
+      end
+
+      # Collects the send's full expression range when it is a +T.absurd+ call.
+      #
+      # @param node [Parser::AST::Node] The send node being visited.
+      #
+      # @return [Parser::AST::Node] The rebuilt node (discarded by AbstractAnalysis#run).
+      sig { params(node: Parser::AST::Node).returns(Parser::AST::Node) }
+      def on_send(node)
+        receiver, method_name = node.children
+        @ranges << line_range(node) if method_name == :absurd && T_RECEIVERS.include?(receiver)
+
+        super
+      end
+
+      # Collects the block's full expression range when the block's send is a +T.type_alias+ or a multi-line +sig+.
+      #
+      # @param node [Parser::AST::Node] The block node being visited.
+      #
+      # @return [Parser::AST::Node] The rebuilt node (discarded by AbstractAnalysis#run).
+      sig { params(node: Parser::AST::Node).returns(Parser::AST::Node) }
+      def on_block(node)
+        receiver, method_name = node.children.first.children
+        range = line_range(node)
+
+        case method_name
+        when :type_alias
+          @ranges << range if T_RECEIVERS.include?(receiver)
+        when :sig
+          # Any receiver qualifies: bare sig blocks and forms like T::Sig::WithoutRuntime.sig are all sigs. A
+          # non-Sorbet DSL also named `sig` would be over-matched, an accepted risk documented in the README.
+          @ranges << range if range.first < range.last
+        end
+
+        super
+      end
+
+      private
+
+      # @param node [Parser::AST::Node] The node whose source span to convert.
+      #
+      # @return [Range<Integer>] The node's 1-indexed first-to-last line range.
+      sig { params(node: Parser::AST::Node).returns(T::Range[Integer]) }
+      def line_range(node)
+        expression = node.loc.expression
+        expression.first_line..expression.last_line
+      end
+    end
+  end
+end

data/lib/simplecov/sorbet/version.rb

@@ -3,6 +3,6 @@
 
 module SimpleCov
   module Sorbet
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/simplecov/sorbet.rb

@@ -7,13 +7,13 @@ require "ast_transform"
 require "ast_transform/abstract_analysis"
 
 require "simplecov/sorbet/version"
-require "simplecov/sorbet/type_alias_ranges"
+require "simplecov/sorbet/ignored_ranges"
 require "simplecov/sorbet/directive_extension"
 
 module SimpleCov
-  # SimpleCov extension for Sorbet codebases: skips constructs Sorbet makes runtime-unreachable by design, starting
-  # with multi-line +T.type_alias+ blocks. Requiring this file installs the extension; Module#prepend is idempotent,
-  # so requiring it more than once is harmless.
+  # SimpleCov extension for Sorbet codebases: skips type-level Sorbet constructs coverage should not measure —
+  # multi-line +T.type_alias+ blocks, +sig+ blocks, and +T.absurd+ sends. Requiring this file installs the
+  # extension; Module#prepend is idempotent, so requiring it more than once is harmless.
   module Sorbet
   end
 end

data/simplecov-sorbet.gemspec

@@ -10,10 +10,10 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Jean-Philippe Duchesne"]
   spec.email         = ["jpduchesne89@gmail.com"]
 
-  spec.summary       = "SimpleCov extension that skips runtime-unreachable Sorbet constructs (T.type_alias blocks)."
-  spec.description   = "Multi-line T.type_alias blocks never execute (sorbet-runtime resolves aliases lazily), " \
-    "so SimpleCov reports them as uncovered. This extension detects them syntactically and feeds their line " \
-    "ranges into SimpleCov's skip machinery."
+  spec.summary       = "SimpleCov extension that skips type-level Sorbet constructs (T.type_alias, sig, T.absurd)."
+  spec.description   = "Type-level Sorbet constructs read as coverage misses: multi-line T.type_alias and sig " \
+    "blocks evaluate lazily or never, and T.absurd is unreachable by definition. This extension detects them " \
+    "syntactically and feeds their line ranges into SimpleCov's skip machinery."
   spec.homepage      = "https://github.com/d3mlabs/simplecov-sorbet"
   spec.license       = "MIT"
   spec.files         = %x(git ls-files -z).split("\x0").reject do |f|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simplecov-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jean-Philippe Duchesne
@@ -52,9 +52,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Multi-line T.type_alias blocks never execute (sorbet-runtime resolves
-  aliases lazily), so SimpleCov reports them as uncovered. This extension detects
-  them syntactically and feeds their line ranges into SimpleCov's skip machinery.
+description: 'Type-level Sorbet constructs read as coverage misses: multi-line T.type_alias
+  and sig blocks evaluate lazily or never, and T.absurd is unreachable by definition.
+  This extension detects them syntactically and feeds their line ranges into SimpleCov''s
+  skip machinery.'
 email:
 - jpduchesne89@gmail.com
 executables: []
@@ -72,13 +73,14 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/release.rb
 - bin/tapioca
 - dependencies.rb
 - dev.yml
 - lib/simplecov-sorbet.rb
 - lib/simplecov/sorbet.rb
 - lib/simplecov/sorbet/directive_extension.rb
-- lib/simplecov/sorbet/type_alias_ranges.rb
+- lib/simplecov/sorbet/ignored_ranges.rb
 - lib/simplecov/sorbet/version.rb
 - simplecov-sorbet.gemspec
 homepage: https://github.com/d3mlabs/simplecov-sorbet
@@ -103,6 +105,6 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: SimpleCov extension that skips runtime-unreachable Sorbet constructs (T.type_alias
-  blocks).
+summary: SimpleCov extension that skips type-level Sorbet constructs (T.type_alias,
+  sig, T.absurd).
 test_files: []

data/lib/simplecov/sorbet/type_alias_ranges.rb

@@ -1,49 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module SimpleCov
-  module Sorbet
-    # Read-only analysis pass collecting the line ranges of +T.type_alias+ blocks. Their bodies are
-    # runtime-unreachable by design: sorbet-runtime resolves aliases lazily and collection checks are shallow, so a
-    # multi-line alias block never executes and reads as a permanent coverage miss. Detection is purely syntactic —
-    # this gem never loads Sorbet's type system.
-    class TypeAliasRanges < ASTTransform::AbstractAnalysis
-      extend T::Sig
-
-      # Structural patterns for the alias send (node equality ignores source locations): +T.type_alias+ and its
-      # explicit top-level form +::T.type_alias+.
-      TYPE_ALIAS_SENDS = T.let(
-        [
-          s(:send, s(:const, nil, :T), :type_alias),
-          s(:send, s(:const, s(:cbase), :T), :type_alias),
-        ].freeze,
-        T::Array[Parser::AST::Node],
-      )
-
-      # One line range per alias block, in source order.
-      sig { returns(T::Array[T::Range[Integer]]) }
-      attr_reader :ranges
-
-      sig { void }
-      def initialize
-        @ranges = T.let([], T::Array[T::Range[Integer]])
-        super
-      end
-
-      # Collects the block's full expression range when the block's send is a +T.type_alias+.
-      #
-      # @param node [Parser::AST::Node] The block node being visited.
-      #
-      # @return [Parser::AST::Node] The rebuilt node (discarded by AbstractAnalysis#run).
-      sig { params(node: Parser::AST::Node).returns(Parser::AST::Node) }
-      def on_block(node)
-        if TYPE_ALIAS_SENDS.include?(node.children.first)
-          expression = node.loc.expression
-          @ranges << (expression.first_line..expression.last_line)
-        end
-
-        super
-      end
-    end
-  end
-end