rigortype 0.3.8 → 0.3.9

data/lib/rigor/effects/liskov_check.rb

@@ -56,16 +56,16 @@ module Rigor
 
       module_function
 
-      # @param table [EffectTable] the run's propagated graph.
-      # @param superclasses [Hash{String => Array<String>}] the collector's as-written superclass
+      # @param table — the run's propagated graph.
+      # @param superclasses — the collector's as-written superclass
       #   candidate lists (`FileCollection#superclasses`).
-      # @param method_envelopes [Hash{String => Envelope}] per-method envelopes, as written.
-      # @param class_envelopes [Hash{String => Envelope}] class- / module-level envelopes, to distribute.
-      # @param config_envelopes [Hash{String => Envelope}] `effects.envelopes:` entries already resolved
+      # @param method_envelopes — per-method envelopes, as written.
+      # @param class_envelopes — class- / module-level envelopes, to distribute.
+      # @param config_envelopes — `effects.envelopes:` entries already resolved
       #   to the classes they select.
-      # @param positions [EnvelopeCheck::Positions] where the override's `def` is.
-      # @param apply_tolerated [Boolean] false judges against `proven` — `--no-tolerated-effects`.
-      # @return [Array<Finding>] sorted by position then key then label.
+      # @param positions — where the override's `def` is.
+      # @param apply_tolerated — false judges against `proven` — `--no-tolerated-effects`.
+      # @return sorted by position then key then label.
       def run(table:, superclasses:, method_envelopes:, class_envelopes:, config_envelopes: {},
               positions: EnvelopeCheck::Positions.empty, apply_tolerated: true)
         # The distributed strata, over a base of the raw per-method annotations: a base class whose method

data/lib/rigor/effects/method_key.rb

@@ -14,7 +14,7 @@ module Rigor
     module MethodKey
       module_function
 
-      # @return [Array(String, String, String), nil] `[owner, separator, selector]`, or nil when `key` is
+      # @return `[owner, separator, selector]`, or nil when `key` is
       #   not a method key at all.
       def split(key)
         text = key.to_s

data/lib/rigor/effects/plugin_facts.rb

@@ -77,11 +77,10 @@ module Rigor
         @empty ||= new(contributions: [], superclasses: NO_ROWS, includes: NO_ROWS)
       end
 
-      # @param plugin_registry [Rigor::Plugin::Registry, nil]
-      # @param superclasses [Hash{String=>String,Array<String>}] the project's as-written superclass table
+      # @param superclasses — the project's as-written superclass table
       #   (`Scope::DiscoveryIndex#discovered_superclasses`). Empty is legal and simply means no row matches
       #   through inheritance.
-      # @param includes [Hash{String=>Array<String>}] the project's as-written include / prepend table
+      # @param includes — the project's as-written include / prepend table
       #   (`Scope::DiscoveryIndex#discovered_includes`), for the frameworks whose contract is a module
       #   rather than a base class (#456).
       def self.build(plugin_registry, superclasses: NO_ROWS, includes: NO_ROWS)
@@ -144,9 +143,8 @@ module Rigor
 
       # The row colouring `owner`'s `selector`, found on `owner` itself or on a project ancestor of it.
       #
-      # @param owner [String, nil] the receiver's class name as the syntax or the typer named it
-      # @param singleton [Boolean] whether the call is `Owner.selector`
-      # @return [Row, nil]
+      # @param owner — the receiver's class name as the syntax or the typer named it
+      # @param singleton — whether the call is `Owner.selector`
       def class_row(owner, singleton, selector)
         return nil if owner.nil? || @class_rows.empty?
 

data/lib/rigor/effects/propagator.rb

@@ -45,10 +45,9 @@ module Rigor
 
       module_function
 
-      # @param collection [FileCollection] the run's merged per-file collections
-      # @param discharge [Discharge] the `effects.tolerated:` policy the undischarged lane is computed
+      # @param collection — the run's merged per-file collections
+      # @param discharge — the `effects.tolerated:` policy the undischarged lane is computed
       #   under; {Discharge.none} makes the two lanes equal.
-      # @return [EffectTable]
       def propagate(collection, discharge: Discharge.none)
         return EffectTable.empty if collection.summaries.empty?
 

data/lib/rigor/effects/scanner.rb

@@ -184,7 +184,7 @@ module Rigor
       # per unit (ADR-103 WD13): a unit the scanner cannot finish is recorded as non-exhaustive with
       # `collector-error` and its siblings are unaffected.
       #
-      # @return [UnitScan, nil] the finished scan, or nil when the unit failed soft
+      # @return the finished scan, or nil when the unit failed soft
       def add_unit(class_name, method_name, singleton, body, parameters)
         key = "#{class_name}#{singleton ? '.' : '#'}#{method_name}"
         names = parameter_names(parameters)

data/lib/rigor/effects/signature_sources.rb

@@ -52,9 +52,8 @@ module Rigor
         stripped.start_with?(root) ? stripped[root.length..] : stripped
       end
 
-      # @param signature_paths [Array<String>, nil] the configured roots; empty / nil takes the default.
-      # @param virtual_rbs [Array<Array(String, String)>, nil] the loader's virtual entries.
-      # @return [Array<Array(String, String)>]
+      # @param signature_paths — the configured roots; empty / nil takes the default.
+      # @param virtual_rbs — the loader's virtual entries.
       def collect(signature_paths:, virtual_rbs: nil)
         files = roots(signature_paths).flat_map { |root| Dir.glob(File.join(root.to_s, "**", "*.rbs")).sort }
         sources = files.filter_map do |path|
@@ -76,8 +75,7 @@ module Rigor
       # residual reports one annotation per run, so the carrier a run holds past the environment's own
       # lifetime is a single synthesized buffer rather than the project's whole virtual tree.
       #
-      # @param virtual_rbs [Array<Array(String, String)>, nil]
-      # @return [Array<Array(String, String)>] zero or one pair.
+      # @return zero or one pair.
       def annotated_carrier(virtual_rbs)
         Array(virtual_rbs).each do |name, content|
           return [[name.to_s, content.to_s]] if ANNOTATION_HINT.match?(content)

data/lib/rigor/effects/snapshot.rb

@@ -117,12 +117,12 @@ module Rigor
       class << self
         # Builds the snapshot a run's effect table describes.
         #
-        # @param table [EffectTable] the propagated graph
-        # @param configuration [Rigor::Configuration] supplies the reach globs and the digested block
-        # @param sources [Hash{String=>Array<String>}] `Runner#effect_sources` — where each unit is defined
-        # @param full [Boolean] keep the rows {#omit?} drops
-        # @param registry [Registry] the vocabulary whose version the header carries
-        # @param project_root [String] what `sources` paths are relativised against for glob matching
+        # @param table — the propagated graph
+        # @param configuration — supplies the reach globs and the digested block
+        # @param sources — `Runner#effect_sources` — where each unit is defined
+        # @param full — keep the rows {#omit?} drops
+        # @param registry — the vocabulary whose version the header carries
+        # @param project_root — what `sources` paths are relativised against for glob matching
         def build(table:, configuration:, sources: {}, full: false, registry: Registry.default,
                   project_root: Dir.pwd)
           globs = expand_reach(configuration.effects_snapshot_reach)
@@ -146,10 +146,10 @@ module Rigor
         # It is built beside the snapshot and never inside it: the file stays flat and undischarged, and
         # this index exists only for the duration of one comparison ({SnapshotDiff}).
         #
-        # @param snapshot [Snapshot] the current side, already built
-        # @param table [EffectTable] the run that produced it
-        # @param discharge [Discharge] the policy
-        # @return [Hash, nil] nil when the policy discharges nothing, which is the common case
+        # @param snapshot — the current side, already built
+        # @param table — the run that produced it
+        # @param discharge — the policy
+        # @return nil when the policy discharges nothing, which is the common case
         def undischarged_index(snapshot:, table:, discharge:)
           return nil if discharge.inert?
 

data/lib/rigor/effects/snapshot_diff.rb

@@ -86,7 +86,7 @@ module Rigor
       # Compares `current` against `recorded`. `recorded` may be nil — no snapshot on disk at all, which
       # is drift with a routed message rather than an error.
       #
-      # @param undischarged [Hash] `{table name => {symbol => [label]}}` — the current side's labels that
+      # @param undischarged — `{table name => {symbol => [label]}}` — the current side's labels that
       #   survive per-origin discharge ({Snapshot.undischarged_index}). Optional; omitting it judges every
       #   event by label.
       def self.compare(recorded:, current:, tolerated: [], gate: :symmetric, strict_tolerated: false,

data/lib/rigor/effects/unit_scan.rb

@@ -87,7 +87,7 @@ module Rigor
       # the enclosing method contains. A non-literal name has no key to file the block under, so it stays
       # contained in the enclosing method and this returns nil.
       #
-      # @return [Array, nil] `[name, singleton, body, parameters]`
+      # @return `[name, singleton, body, parameters]`
       def self.define_method_unit(node)
         return nil unless node.name == :define_method && node.receiver.nil?
 
@@ -100,17 +100,17 @@ module Rigor
         [first.unescaped, false, block.body, block.parameters]
       end
 
-      # @param singleton [Boolean] whether the unit's `self` is the class object (`def self.x`,
+      # @param singleton — whether the unit's `self` is the class object (`def self.x`,
       #   `class << self`) — the axis that separates `mutate.self` from `mutate.static` on an ivar write
-      # @param block_parameter [String, nil] the unit's `&blk` parameter name, if any; a call on it is
+      # @param block_parameter — the unit's `&blk` parameter name, if any; a call on it is
       #   forwarding, not an opaque callable
-      # @param calls [Hash] node-identity table of {Collector::CallRecord}s
-      # @param attribution [Attribution] the project's `effects.attribution:` table
-      # @param envelopes [EnvelopeIndex] the envelopes a call site may import as a `≤` bound (#386)
-      # @param plugin_facts [PluginFacts] the loaded plugins' `effect_attributions:` (#387)
-      # @param owner_class [String, nil] the class this unit is defined on — the carrier an
+      # @param calls — node-identity table of {Collector::CallRecord}s
+      # @param attribution — the project's `effects.attribution:` table
+      # @param envelopes — the envelopes a call site may import as a `≤` bound (#386)
+      # @param plugin_facts — the loaded plugins' `effect_attributions:` (#387)
+      # @param owner_class — the class this unit is defined on — the carrier an
       #   implicit-self call's envelope is looked up under, since the syntax spells `Kernel#name`
-      # @param method_name [String, nil] this unit's own selector — what a `super` in its body names as
+      # @param method_name — this unit's own selector — what a `super` in its body names as
       #   the target the propagator resolves above `owner_class` (#446). With no name to state, a `super`
       #   taints instead.
       def initialize(singleton:, parameters:, block_parameter:, owned_locals:, calls:, # rubocop:disable Metrics/ParameterLists
@@ -283,7 +283,7 @@ module Rigor
       # Three receiver shapes, tried nearest-syntax first — a written receiver path (`Rails.cache.read`),
       # a receiver rooted at implicit self inside a framework class (`session[:x] = 1`), and the receiver's
       # class through the project's inheritance chain (`user.save`).
-      # @return [PluginFacts::Row, nil] the row that claimed this call, for {#visit_call} to read as a bound
+      # @return the row that claimed this call, for {#visit_call} to read as a bound
       def attribute_plugin(node, record)
         return nil unless @plugin_facts.attributions?
 

data/lib/rigor/effects/unknown_label_check.rb

@@ -30,10 +30,6 @@ module Rigor
 
       module_function
 
-      # @param method_envelopes [Hash{String => Envelope}]
-      # @param class_envelopes [Hash{String => Envelope}]
-      # @param registry [Rigor::Effects::Registry]
-      # @return [Array<Finding>]
       def for_envelopes(method_envelopes:, class_envelopes:, registry:)
         seen = {}
         declarations(method_envelopes, class_envelopes).each do |envelope|
@@ -49,10 +45,9 @@ module Rigor
         seen.values
       end
 
-      # @param labels [Array<String>] the list as written, in source order.
-      # @param key_path [String] the `.rigor.yml` key, for the message (`effects.tolerated`).
-      # @param consequence [String] what the degradation cost, for the message.
-      # @return [Array<Finding>]
+      # @param labels — the list as written, in source order.
+      # @param key_path — the `.rigor.yml` key, for the message (`effects.tolerated`).
+      # @param consequence — what the degradation cost, for the message.
       def for_config(labels:, key_path:, consequence:, registry:)
         tokens = Array(labels).map(&:to_s)
         tokens.filter_map do |token|

data/lib/rigor/effects/unknown_label_report.rb

@@ -17,10 +17,9 @@ module Rigor
     # {.for} answers `nil` unless {LabelIntent} says the spelling is evidently a label — the whole
     # point of the diagnostic is that it fires where intent is evident and nowhere else.
     class UnknownLabelReport < Data.define(:token, :suggestion, :retirement)
-      # @param token [String] the spelling as written.
-      # @param registry [Rigor::Effects::Registry, nil] the vocabulary after plugin load.
-      # @param siblings [Array<String>] the other tokens written alongside it.
-      # @return [UnknownLabelReport, nil]
+      # @param token — the spelling as written.
+      # @param registry — the vocabulary after plugin load.
+      # @param siblings — the other tokens written alongside it.
       def self.for(token:, registry:, siblings: [])
         return nil unless LabelIntent.evident?(token, registry, siblings: siblings)
 

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -46,14 +46,14 @@ module Rigor
         "bundler", "rubygems"
       ].freeze
 
-      # @param bundle_path [String, Pathname, nil] explicit path to the bundler install root. When `nil`,
+      # @param bundle_path — explicit path to the bundler install root. When `nil`,
       #   falls back to `auto_detect` if `auto_detect:` is true.
-      # @param project_root [String] resolution base for relative `bundle_path:` and the auto-detect search.
-      # @param auto_detect [Boolean] when true and `bundle_path:` is nil, try `.bundle/config`'s
+      # @param project_root — resolution base for relative `bundle_path:` and the auto-detect search.
+      # @param auto_detect — when true and `bundle_path:` is nil, try `.bundle/config`'s
       #   `BUNDLE_PATH:` and `vendor/bundle/` under `project_root`.
-      # @param skip_gems [Set<String>] gem names to exclude from discovery. Defaults to
+      # @param skip_gems — gem names to exclude from discovery. Defaults to
       #   {SKIPPED_GEMS_BY_DEFAULT}.
-      # @param locked_gems [Hash{String => LockfileResolver::LockedGem}, nil] Optional O4-Layer-3 filter.
+      # @param locked_gems — Optional O4-Layer-3 filter.
       #   When non-nil and non-empty, only `sig/` directories whose gem `(name, version, platform)` tuple
       #   matches a lockfile entry are returned. Bundle entries absent from the lockfile (or at a drifted
       #   version) are silently dropped — the lockfile is treated as the source of truth for "what gems this
@@ -63,7 +63,7 @@ module Rigor
       #   source keeps its stale `bundler/gems/` directory under the SAME name until a `bundle clean`. Pass
       #   `nil` (the default) to keep the pre-Layer-3 behaviour of returning every non-skipped `sig/` under
       #   the bundle.
-      # @return [Array<Pathname>] every `<gem-dir>/sig` directory under the resolved bundle path, minus any
+      # @return every `<gem-dir>/sig` directory under the resolved bundle path, minus any
       #   whose gem name is in `skip_gems` and (when `locked_gems` is supplied) minus any whose `(name,
       #   version, platform)` does not match a lockfile entry.
       def self.discover(bundle_path:, project_root: Dir.pwd, auto_detect: true,

data/lib/rigor/environment/class_registry.rb

@@ -136,8 +136,10 @@ module Rigor
 
       private
 
+      # Allocates only when there is a prefix to strip (see `Environment#normalize_class_name`).
       def normalize_name(name)
-        name.to_s.delete_prefix("::")
+        name = name.to_s
+        name.start_with?("::") ? name.delete_prefix("::") : name
       end
     end
   end

data/lib/rigor/environment/failure_slot.rb

@@ -16,12 +16,12 @@ module Rigor
         @value = nil
       end
 
-      # @param value [Array] a Marshal-clean tuple — the fork pool ships it back from the worker.
+      # @param value — a Marshal-clean tuple — the fork pool ships it back from the worker.
       def record(value)
         @value = value.freeze if @value.nil?
       end
 
-      # @return [Array, nil] the recorded tuple, or nil when the build never failed.
+      # @return the recorded tuple, or nil when the build never failed.
       attr_reader :value
     end
   end

data/lib/rigor/environment/installed_gem_set.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "lockfile_resolver"
+
+module Rigor
+  class Environment
+    # Issue #530 — the gem set for a project that has NO `Gemfile.lock`.
+    #
+    # ADR-82 WD9's constant-ownership index is driven by the LOCKED gem set, so a project without a
+    # lockfile (a plain library, a `gemspec`-only gem, an app vendored outside Bundler) handed the index
+    # nothing at all: every constant reaching into a real, installed, RBS-less gem recorded the generic
+    # cause, and the entire gem boundary reported as `engine_gap` — "report this to Rigor" — where the
+    # honest story is `add_rbs`. Measured on slim, whose whole Temple boundary lands that way while haml,
+    # which has a lockfile, attributes the same gem correctly.
+    #
+    # Degrading to the gems that are actually INSTALLED keeps ADR-82's honesty criterion intact. A name
+    # here is a gem that exists on disk; the index still has to READ its entry file before claiming any
+    # constant, and its lack of RBS is established by the same {RbsCoverageReport.classify} pass the
+    # lock-driven path uses. The version is the one on disk rather than a declared one — which is the
+    # version a lockfile-less project would load anyway.
+    #
+    # Only the missing-gem provenance index consumes this. The ADR-72 gem overlays stay Gemfile.lock-gated:
+    # an overlay changes what type-checks, so it needs the project's own declaration, while this
+    # side-channel only changes a label.
+    module InstalledGemSet
+      module_function
+
+      # @param bundle_path — the target's resolved bundler install root, or nil.
+      # @return frozen `gem name => LockfileResolver::LockedGem`, the shape
+      #   {RbsCoverageReport.classify} consumes. Empty when neither resolver sees anything, which leaves
+      #   today's generic cause in place.
+      def gems(bundle_path: nil)
+        found = from_bundle_tree(bundle_path)
+        found = from_installed_specs if found.empty?
+        found.freeze
+      end
+
+      # `<bundle>/ruby/X.Y.Z/gems/<name>-<version>/` — the same pure-filesystem layout
+      # {MissingGemConstantIndex.bundle_gem_dirs} walks, preferred over the host's gems so a project that
+      # vendored its bundle without committing the lockfile is read from its own tree. A platform-tagged
+      # directory (`ffi-1.17.4-aarch64-linux-gnu`) does not split into a name/version pair and is skipped:
+      # those gems ship native code, not the pure-Ruby constants this feeds.
+      def from_bundle_tree(bundle_path)
+        return {} if bundle_path.nil?
+
+        base = Pathname.new(bundle_path)
+        return {} unless base.directory?
+
+        Dir.glob(base.join("ruby", "*", "gems", "*")).each_with_object({}) do |dir, acc|
+          name, version = split_name_version(File.basename(dir))
+          next unless name
+
+          acc[name] ||= locked_gem(name, version)
+        end
+      end
+
+      # The gems the RUNNING Ruby can load. For the shipped `gem install rigortype` distribution that IS a
+      # lockfile-less project's gem environment — the same set its own `require` would reach. Under
+      # `bundle exec` it is the analyzer's own bundle instead (the `Gem.paths`-no-ops-under-Bundler
+      # mechanism ADR-90 documents), which yields fewer names, never wrong ones. Highest version per name,
+      # because `stubs` promises no ordering.
+      def from_installed_specs
+        Gem::Specification.stubs.each_with_object({}) do |stub, acc|
+          previous = acc[stub.name]
+          next if previous && Gem::Version.new(previous.version) >= stub.version
+
+          acc[stub.name] = locked_gem(stub.name, stub.version.to_s)
+        end
+      rescue StandardError
+        {}
+      end
+
+      def locked_gem(name, version)
+        LockfileResolver::LockedGem.new(name: name, version: version, platform: "ruby")
+      end
+
+      # Splits a gem install directory's basename. The version tail is anchored on a leading digit and must
+      # carry no further hyphen, which is what excludes the platform-tagged variants above.
+      def split_name_version(basename)
+        match = /\A(.+)-(\d[^-]*)\z/.match(basename)
+        match ? [match[1], match[2]] : nil
+      end
+    end
+  end
+end

data/lib/rigor/environment/lockfile_resolver.rb

@@ -39,13 +39,13 @@ module Rigor
         end
       end
 
-      # @param lockfile_path [String, Pathname, nil] explicit path to the Gemfile.lock. When `nil`, falls
+      # @param lockfile_path — explicit path to the Gemfile.lock. When `nil`, falls
       #   back to `auto_detect` if `auto_detect:` is true.
-      # @param project_root [String] resolution base for a relative `lockfile_path:` and the auto-detect
+      # @param project_root — resolution base for a relative `lockfile_path:` and the auto-detect
       #   search.
-      # @param auto_detect [Boolean] when true and `lockfile_path:` is nil, look for
+      # @param auto_detect — when true and `lockfile_path:` is nil, look for
       #   `<project_root>/Gemfile.lock`.
-      # @return [Hash{String => LockedGem}] frozen map of gem name → locked entry. Returns the empty frozen
+      # @return frozen map of gem name → locked entry. Returns the empty frozen
       #   hash when no lockfile is resolvable, when the file is unreadable, or when Bundler refuses to parse
       #   it.
       def self.locked_gems(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
@@ -59,6 +59,53 @@ module Rigor
         parse(resolved)
       end
 
+      # The gems the project declares for itself — the lockfile's `DEPENDENCIES` section, which is what a
+      # `Gemfile` actually asked for, as opposed to {locked_gems}'s full resolved graph. A consumer that
+      # advises the user about their own stack has to read this one: `minitest`, `i18n`, `activesupport` and
+      # `ffi` sit in nearly every Rails lock as somebody else's dependency, so matching against the resolved
+      # graph advises about gems the project never chose.
+      #
+      # @param lockfile_path — explicit path to the Gemfile.lock; `nil` falls back to `auto_detect`.
+      # @param project_root — resolution base for a relative `lockfile_path:` and the auto-detect search.
+      # @param auto_detect — when true and `lockfile_path:` is nil, look for `<project_root>/Gemfile.lock`.
+      # @return frozen set of gem names. Empty when no lockfile is resolvable, when it is unreadable, when
+      #   Bundler refuses to parse it, or when the lockfile has no `DEPENDENCIES` section at all.
+      def self.direct_dependency_names(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
+        resolved = resolve_lockfile_path(
+          lockfile_path: lockfile_path,
+          project_root: project_root,
+          auto_detect: auto_detect
+        )
+        return EMPTY_NAMES unless resolved
+
+        parse_dependency_names(resolved)
+      end
+
+      EMPTY_NAMES = Set.new.freeze
+      private_constant :EMPTY_NAMES
+
+      def self.parse_dependency_names(path)
+        require "bundler"
+      rescue LoadError => e
+        warn "rigor: cannot read #{path}: bundler is not available (#{e.message})"
+        EMPTY_NAMES
+      else
+        do_parse_dependency_names(path)
+      end
+      private_class_method :parse_dependency_names
+
+      def self.do_parse_dependency_names(path)
+        parser = Bundler::LockfileParser.new(File.read(path.to_s))
+        # `#dependencies` is the parsed `DEPENDENCIES` section keyed by gem name, so the version constraint
+        # and the pinned-source `!` suffix are already stripped for us. The upstream bundler RBS shim does
+        # not declare it.
+        parser.dependencies.keys.to_set { |name| -name.to_s }.freeze # rigor:disable undefined-method
+      rescue StandardError => e
+        warn "rigor: ignoring malformed #{path} (#{e.class}: #{e.message})"
+        EMPTY_NAMES
+      end
+      private_class_method :do_parse_dependency_names
+
       # Returns the resolved lockfile path (`Pathname`) or `nil` when neither explicit nor auto-detect
       # produces one. Public so the stats banner can show what rigor picked up.
       def self.resolve_lockfile_path(lockfile_path:, project_root: Dir.pwd, auto_detect: true)

data/lib/rigor/environment/missing_gem_constant_index.rb

@@ -37,12 +37,12 @@ module Rigor
     module MissingGemConstantIndex
       module_function
 
-      # @param gems [Enumerable<Array(String, String)>] `[gem_name, version]` pairs (the `:missing` rows of
+      # @param gems — `[gem_name, version]` pairs (the `:missing` rows of
       #   {RbsCoverageReport}).
-      # @param bundle_path [String, Pathname, nil] the target's resolved bundler install root, or nil.
-      # @param spec_resolver [#call] `(name, version) -> String?` fallback dir resolver. Injectable for
+      # @param bundle_path — the target's resolved bundler install root, or nil.
+      # @param spec_resolver — `(name, version) -> String?` fallback dir resolver. Injectable for
       #   specs; the default is the RubyGems-metadata lookup (no code load).
-      # @return [Hash{String => String}] frozen `root constant name => gem name`. On a collision (two gems
+      # @return frozen `root constant name => gem name`. On a collision (two gems
       #   declaring the same top-level constant) the first gem wins — the CAUSE recorded downstream
       #   (external gem without RBS) is true under either owner.
       def build(gems, bundle_path: nil, spec_resolver: method(:installed_gem_dir))

data/lib/rigor/environment/rbs_collection_discovery.rb

@@ -37,17 +37,17 @@ module Rigor
       DEFAULT_COLLECTION_PATH = ".gem_rbs_collection"
       private_constant :DEFAULT_COLLECTION_PATH
 
-      # @param lockfile_path [String, Pathname, nil] explicit path to `rbs_collection.lock.yaml`. When `nil`,
+      # @param lockfile_path — explicit path to `rbs_collection.lock.yaml`. When `nil`,
       #   falls back to `auto_detect` if `auto_detect:` is true.
-      # @param project_root [String] resolution base for relative `lockfile_path:` and the auto-detect
+      # @param project_root — resolution base for relative `lockfile_path:` and the auto-detect
       #   search.
-      # @param auto_detect [Boolean] when true and `lockfile_path:` is nil, look for
+      # @param auto_detect — when true and `lockfile_path:` is nil, look for
       #   `<project_root>/rbs_collection.lock.yaml`.
-      # @param skip_gem_names [Array<String>, Set<String>] gem names rigor already loads from its bundled
+      # @param skip_gem_names — gem names rigor already loads from its bundled
       #   stdlib (the merged `DEFAULT_LIBRARIES + libraries:` set). Entries whose `name` is in this set are
       #   dropped regardless of `source.type` to avoid `RBS::DuplicatedDeclarationError` on
       #   stdlib-extracted default gems. Defaults to empty.
-      # @return [Array<Pathname>] every `<collection_path>/<gem-name>/<gem-version>/` directory listed in the
+      # @return every `<collection_path>/<gem-name>/<gem-version>/` directory listed in the
       #   lockfile whose entry has a non-skipped source type, whose `name` is not in `skip_gem_names:`, and
       #   whose directory exists on disk. Returns `[]` when no lockfile is resolvable, when the YAML is
       #   unreadable, or when the collection path doesn't exist.

data/lib/rigor/environment/rbs_coverage_report.rb

@@ -35,16 +35,16 @@ module Rigor
         "idn-ruby", "mysql2", "nokogiri", "pg", "prism", "racc", "redis", "rubygems"
       ].freeze
 
-      # @param locked_gems [Hash{String => LockfileResolver::LockedGem}] The lockfile-resolved gem set. Empty
+      # @param locked_gems — The lockfile-resolved gem set. Empty
       #   hash → no coverage analysis to do.
-      # @param default_libraries [Array<String>] gem names rigor auto-loads through
+      # @param default_libraries — gem names rigor auto-loads through
       #   `RBS::EnvironmentLoader#add(library:)`. Pass `Rigor::Environment::DEFAULT_LIBRARIES` from callers
       #   running in a project context.
-      # @param bundle_sig_paths [Array<Pathname, String>] the discovered `<bundle>/.../gems/<name>-<ver>/sig`
+      # @param bundle_sig_paths — the discovered `<bundle>/.../gems/<name>-<ver>/sig`
       #   paths from {BundleSigDiscovery.discover}.
-      # @param rbs_collection_paths [Array<Pathname, String>] the discovered `<collection>/<name>/<version>/`
+      # @param rbs_collection_paths — the discovered `<collection>/<name>/<version>/`
       #   paths from {RbsCollectionDiscovery.discover}.
-      # @return [Array<Coverage>] one row per locked gem; sorted by gem name for deterministic output.
+      # @return one row per locked gem; sorted by gem name for deterministic output.
       def self.classify(locked_gems:, default_libraries:,
                         bundle_sig_paths:, rbs_collection_paths:)
         default_set = default_libraries.to_set

data/lib/rigor/environment/rbs_hierarchy.rb

@@ -63,8 +63,10 @@ module Rigor
         @ancestor_names_cache[key] = loader.ancestor_names_for(key)
       end
 
+      # Allocates only when there is a prefix to strip (see `Environment#normalize_class_name`).
       def normalize_name(name)
-        name.to_s.delete_prefix("::")
+        name = name.to_s
+        name.start_with?("::") ? name.delete_prefix("::") : name
       end
     end
   end