rigortype 0.3.6 → 0.3.8

data/lib/rigor/cli/type_of_command.rb

@@ -10,6 +10,8 @@ require_relative "../scope"
 require_relative "../source/node_locator"
 require_relative "../inference/fallback_tracer"
 require_relative "../inference/scope_indexer"
+require_relative "../inference/precision_scanner"
+require_relative "../source/node_children"
 require_relative "type_of_renderer"
 require_relative "command"
 require_relative "options"
@@ -26,9 +28,23 @@ module Rigor
     # type-of UX (extra flags, watch mode, streaming output) without bloating the CLI shell. Output formatting is
     # delegated to {TypeOfRenderer}.
     class TypeOfCommand < Command
-      USAGE = "Usage: rigor type-of [options] FILE:LINE:COL"
+      USAGE = "Usage: rigor type-of [options] FILE:LINE[:COL] [FILE:LINE[:COL] ...]"
 
-      Result = Data.define(:file, :line, :column, :node, :type, :tracer)
+      Result = Data.define(:file, :line, :column, :node, :type, :tracer, :enumeration) do
+        def initialize(enumeration: nil, **rest)
+          super
+        end
+      end
+
+      LineEnumeration = Data.define(:total, :shown)
+
+      # One requested position. A nil `column` means "the first 40 expressions starting on this line" — the form that
+      # exists because hand-computing a column is the single most error-prone part of using this command.
+      Target = Data.define(:file, :line, :column)
+
+      # Cap on the expressions one bare `FILE:LINE` prints, so a long line cannot bury the answer.
+      LINE_ENUMERATION_CAP = 40
+      private_constant :LINE_ENUMERATION_CAP
 
       # @return [Integer] CLI exit status.
       def run
@@ -36,10 +52,10 @@ module Rigor
         buffer = Options.resolve_buffer_binding(options, err: @err)
         return CLI::EXIT_USAGE if buffer == :usage_error
 
-        target = parse_position_argument(@argv)
-        return CLI::EXIT_USAGE if target.nil?
+        targets = parse_position_arguments(@argv)
+        return CLI::EXIT_USAGE if targets.nil?
 
-        execute(target: target, options: options, buffer: buffer)
+        execute(targets: targets, options: options, buffer: buffer)
       end
 
       private
@@ -59,38 +75,123 @@ module Rigor
         options
       end
 
-      def execute(target:, options:, buffer: nil)
-        file, line, column = target
-        # Under editor mode the logical `file` may not exist on disk (user editing a new file); the runtime check is
-        # only that the BUFFER is readable, which `resolve_buffer_binding` has already enforced. For non-editor mode
-        # `file` must exist.
+      # One process, N positions. Every invocation used to rebuild the plugin-aware environment and reparse the
+      # file for a single answer, so investigating a chain of expressions cost one process each — the dominant
+      # cost of using this command in anger. The environment is now built once for the whole request and each
+      # file is parsed and scope-indexed once, however many positions land in it.
+      def execute(targets:, options:, buffer: nil)
+        configuration = Configuration.load(options.fetch(:config))
+        environment = project_environment(targets.map(&:file).uniq, configuration)
+        base_scope = Scope.empty(environment: environment)
+
+        results_by_target = Array.new(targets.length)
+        targets.each_with_index.group_by { |target, _index| target.file }.each do |file, indexed_targets|
+          file_results = resolve_file(file, indexed_targets, configuration, base_scope, options, buffer)
+          return file_results if file_results.is_a?(Integer)
+
+          file_results.each { |index, resolved| results_by_target[index] = resolved }
+        end
+        results = results_by_target.compact.flatten(1)
+        return 1 if results.empty?
+
+        TypeOfRenderer.new(out: @out).render(results, format: options.fetch(:format))
+        0
+      end
+
+      # Every result for one file: parsed and indexed once, then each requested position resolved against that
+      # index. Returns an Integer exit status instead when the file itself cannot be probed.
+      def resolve_file(file, indexed_targets, configuration, base_scope, options, buffer)
+        # Under editor mode the logical `file` may not exist on disk (user editing a new file); the runtime check
+        # is only that the BUFFER is readable, which `resolve_buffer_binding` has already enforced.
         physical = buffer ? buffer.resolve(file) : file
         return 1 unless file_exists?(buffer ? physical : file)
 
-        configuration = Configuration.load(options.fetch(:config))
         source = File.read(physical)
         parse_result = Prism.parse(source, filepath: file, version: configuration.target_ruby)
         return 1 if parse_errors?(parse_result, file)
 
-        node = locate_node(source: source, root: parse_result.value, file: file, line: line, column: column)
-        return CLI::EXIT_USAGE if node == :out_of_range
-        return 1 if node.nil?
+        # Built with no tracer attached — it would otherwise double-record fallback events with the per-node
+        # `type_of` calls below.
+        scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: base_scope)
+        locator = Source::NodeLocator.new(source: source, root: parse_result.value)
+        lines = indexed_targets.filter_map { |target, _index| target.line if target.column.nil? }
+        line_nodes, line_totals = collect_line_nodes(parse_result.value, lines)
 
-        tracer = options[:trace] ? Inference::FallbackTracer.new : nil
-        base_scope = Scope.empty(environment: project_environment(file, configuration))
+        resolve_targets(file: file, indexed_targets: indexed_targets, locator: locator, line_nodes: line_nodes,
+                        line_totals: line_totals, scope_index: scope_index, options: options)
+      end
 
-        # Build a per-node scope index so locals bound earlier in the file flow into the scope used to type the queried
-        # node. We build the index with no tracer attached (it would otherwise double-record fallback events with the
-        # second-pass type_of call below), then look up the scope visible at the queried node and run the actual probe
-        # under it.
-        scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: base_scope)
-        node_scope = scope_index[node]
+      def resolve_targets(file:, indexed_targets:, locator:, line_nodes:, line_totals:, scope_index:, options:)
+        indexed_targets.map do |target, index|
+          if target.column.nil?
+            resolved = enumerate_line(file, target.line, line_nodes.fetch(target.line),
+                                      line_totals.fetch(target.line), scope_index, options)
+            next [index, resolved]
+          end
 
-        type = node_scope.type_of(node, tracer: tracer)
-        result = Result.new(file: file, line: line, column: column, node: node, type: type, tracer: tracer)
+          node = locate_node(locator: locator, file: file, line: target.line, column: target.column)
+          return CLI::EXIT_USAGE if node == :out_of_range
+          next [index, []] if node.nil?
 
-        TypeOfRenderer.new(out: @out).render(result, format: options.fetch(:format))
-        0
+          [index, [type_result(file, target.line, target.column, node, scope_index, options)]]
+        end
+      end
+
+      # Collect every requested line in one full syntax walk. Unlike `Source::NodeWalker`, this deliberately
+      # descends into `defined?`: the probe inventories source expressions, including operands Ruby inspects but
+      # does not evaluate. Candidate storage stays bounded while retaining the first 40 nodes in display order.
+      def collect_line_nodes(root, lines)
+        return [{}, {}] if lines.empty?
+
+        candidates = lines.uniq.to_h { |line| [line, []] }
+        totals = candidates.to_h { |line, _nodes| [line, 0] }
+        walk_syntax(root) do |node|
+          line = node.location.start_line
+          nodes = candidates[line]
+          next if nodes.nil?
+          next if Inference::PrecisionScanner::NON_EXPRESSION_NODE_TYPES.include?(node.class.name)
+
+          totals[line] += 1
+          nodes << node
+          trim_line_nodes(nodes) if nodes.length > LINE_ENUMERATION_CAP * 2
+        end
+        candidates.each_value { |nodes| trim_line_nodes(nodes) }
+        [candidates, totals]
+      end
+
+      def walk_syntax(node, &block)
+        return unless node.is_a?(Prism::Node)
+
+        block.call(node)
+        node.rigor_each_child { |child| walk_syntax(child, &block) }
+      end
+
+      def trim_line_nodes(nodes)
+        nodes.sort_by! { |node| [node.location.start_column, -node.location.length] }
+        nodes.slice!(LINE_ENUMERATION_CAP, nodes.length)
+      end
+
+      # Up to 40 expressions STARTING on `line`, outermost first at each 1-based column. This form removes
+      # the column arithmetic: `rigor type-of file.rb:42` answers "what are the types on line 42" without the user
+      # having to guess which byte the receiver starts at.
+      def enumerate_line(file, line, nodes, total, scope_index, options)
+        if nodes.empty?
+          @err.puts("type-of: no expression found on #{file}:#{line}")
+          return []
+        end
+
+        enumeration = LineEnumeration.new(total: total, shown: nodes.length)
+        nodes.map do |node|
+          type_result(file, line, node.location.start_column + 1, node, scope_index, options,
+                      enumeration: enumeration)
+        end
+      end
+
+      def type_result(file, line, column, node, scope_index, options, enumeration: nil)
+        tracer = options[:trace] ? Inference::FallbackTracer.new : nil
+        type = scope_index[node].type_of(node, tracer: tracer)
+        Result.new(file: file, line: line, column: column, node: node, type: type, tracer: tracer,
+                   enumeration: enumeration)
       end
 
       # Builds the plugin-aware environment relative to the probed file, so the reported type matches what `rigor
@@ -99,8 +200,8 @@ module Rigor
       # closes). The probed file is threaded as the synthesizer's `source_files:`. Project-RBS auto-detection
       # roots at CWD today; future work will walk parent directories to find the enclosing `Gemfile`/`*.gemspec`
       # so probes against files outside the current process's CWD still see the right `sig/` tree.
-      def project_environment(file, configuration)
-        ProbeEnvironment.build(configuration: configuration, source_files: [file])
+      def project_environment(files, configuration)
+        ProbeEnvironment.build(configuration: configuration, source_files: files)
       end
 
       def file_exists?(file)
@@ -117,8 +218,8 @@ module Rigor
         true
       end
 
-      def locate_node(source:, root:, file:, line:, column:)
-        node = Source::NodeLocator.at_position(source: source, root: root, line: line, column: column)
+      def locate_node(locator:, file:, line:, column:)
+        node = locator.at_position(line: line, column: column)
         @err.puts("type-of: no expression found at #{file}:#{line}:#{column}") if node.nil?
         node
       rescue Source::NodeLocator::OutOfRangeError => e
@@ -126,19 +227,66 @@ module Rigor
         :out_of_range
       end
 
-      def parse_position_argument(argv)
-        case argv.size
-        when 1
-          parse_colon_form(argv[0])
-        when 3
-          decode_position(*argv)
-        else
-          @err.puts("type-of: expected FILE:LINE:COL or FILE LINE COL")
+      def parse_position_arguments(argv)
+        if argv.empty?
+          @err.puts("type-of: expected FILE:LINE[:COL] or FILE LINE COL")
           @err.puts(USAGE)
-          nil
+          return nil
         end
+
+        colon = argv.map { |arg| try_colon_form(arg) }
+        return colon if colon.all?
+        return legacy_triple(argv) if argv.size == 3 && colon.none?
+        # A single unparseable argument keeps its old, specific diagnosis ("must be integers", "expected
+        # FILE:LINE:COL") rather than the generic multi-position complaint below.
+        return single_colon_form(argv[0]) if argv.size == 1
+
+        @err.puts("type-of: expected FILE:LINE[:COL] (repeatable) or FILE LINE COL, got #{argv.inspect}")
+        @err.puts(USAGE)
+        nil
+      end
+
+      # `FILE:LINE:COL` or `FILE:LINE`, or nil when the argument is not in either form. Silent: the caller
+      # decides whether a nil means "try the three-argument form" or "report a usage error", and a probe should
+      # not print a complaint about a shape it is about to accept under a different reading.
+      def try_colon_form(arg)
+        parts = arg.split(":")
+        return nil if parts.size < 2 || !integer_literal?(parts[-1])
+
+        # Three or more segments is the `FILE:LINE:COL` reading; if its LINE is not a number the argument is a
+        # typo, not a column-less position, and must reach the specific "must be integers" diagnosis.
+        if parts.size >= 3
+          return nil unless integer_literal?(parts[-2])
+
+          Target.new(file: parts[0..-3].join(":"), line: Integer(parts[-2], 10), column: Integer(parts[-1], 10))
+        else
+          Target.new(file: parts[0], line: Integer(parts[-1], 10), column: nil)
+        end
+      end
+
+      def integer_literal?(value)
+        value.match?(/\A\d+\z/)
+      end
+
+      # The pre-batch single-argument path, kept for its error messages. Returns nil after printing one.
+      def single_colon_form(arg)
+        position = parse_colon_form(arg)
+        return nil if position.nil?
+
+        file, line, column = position
+        [Target.new(file: file, line: line, column: column)]
+      end
+
+      def legacy_triple(argv)
+        position = decode_position(*argv)
+        return nil if position.nil?
+
+        file, line, column = position
+        [Target.new(file: file, line: line, column: column)]
       end
 
+      # The strict `FILE:LINE:COL` reading, used only to produce the specific error for a single unparseable
+      # argument. The permissive reading (which also accepts `FILE:LINE`) is {try_colon_form}.
       def parse_colon_form(arg)
         parts = arg.split(":")
         if parts.size < 3
@@ -149,8 +297,7 @@ module Rigor
 
         column = parts.pop
         line = parts.pop
-        file = parts.join(":")
-        decode_position(file, line, column)
+        decode_position(parts.join(":"), line, column)
       end
 
       def decode_position(file, line, column)

data/lib/rigor/cli/type_of_renderer.rb

@@ -20,7 +20,55 @@ module Rigor
 
       private
 
-      def render_text(result)
+      # Takes the whole result list: one invocation can now answer several positions, and a bare `FILE:LINE`
+      # answers up to 40 expressions on that line. A single exact result renders byte-identically to before.
+      def render_text(results)
+        list = Array(results)
+        index = 0
+        first = true
+        while index < list.length
+          @out.puts("") unless first
+          result = list[index]
+          enumeration = result.enumeration
+          if enumeration
+            finish = index + 1
+            finish += 1 while finish < list.length && list[finish].enumeration.equal?(enumeration)
+            render_enumeration(list[index...finish], enumeration)
+            index = finish
+          else
+            render_one_text(result)
+            index += 1
+          end
+          first = false
+        end
+      end
+
+      # A bare `FILE:LINE` asks "what are the types on this line", and the answer is a table: one row per
+      # expression, outermost first at each column, so a method chain reads top to bottom.
+      def render_enumeration(results, enumeration)
+        @out.puts("#{results.first.file}:#{results.first.line}")
+        render_enumeration_rows(results)
+        if enumeration.total > results.length
+          omitted = enumeration.total - results.length
+          @out.puts("  ... #{omitted} additional expressions omitted (limit #{results.length})")
+        end
+        # After the table, never interleaved with it: a `--trace` fallback list between two rows would break the
+        # column alignment the whole form exists for.
+        results.each { |result| render_text_fallbacks(result) }
+      end
+
+      def render_enumeration_rows(results)
+        width = results.map { |result| node_label(result).length }.max
+        results.each do |result|
+          @out.puts(format("  %4d  %-#{width}s  %s", result.column, node_label(result), result.type.describe))
+        end
+      end
+
+      def node_label(result)
+        result.node.class.name.to_s.delete_prefix("Prism::")
+      end
+
+      def render_one_text(result)
         @out.puts("#{result.file}:#{result.line}:#{result.column}")
         @out.puts("node:    #{result.node.class}")
         @out.puts("type:    #{result.type.describe}")
@@ -40,7 +88,28 @@ module Rigor
         end
       end
 
-      def render_json(result)
+      # A single result keeps the flat object it has always emitted, so existing consumers are untouched; a
+      # multi-position request wraps them in `results` rather than printing several documents to one stream.
+      def render_json(results)
+        list = Array(results)
+        payload = list.size == 1 ? result_to_h(list.first) : { results: list.map { |r| result_to_h(r) } }
+        enumerations = line_enumerations(list)
+        payload[:line_enumerations] = enumerations unless enumerations.empty?
+        @out.puts(JSON.pretty_generate(payload))
+      end
+
+      def line_enumerations(results)
+        seen = {}.compare_by_identity
+        results.filter_map do |result|
+          enumeration = result.enumeration
+          next if enumeration.nil? || seen.key?(enumeration)
+
+          seen[enumeration] = true
+          { file: result.file, line: result.line, shown: enumeration.shown, total: enumeration.total }
+        end
+      end
+
+      def result_to_h(result)
         payload = {
           file: result.file,
           line: result.line,
@@ -50,7 +119,7 @@ module Rigor
           erased: result.type.erase_to_rbs
         }
         payload[:fallbacks] = result.tracer.map { |event| fallback_to_h(event) } if result.tracer
-        @out.puts(JSON.pretty_generate(payload))
+        payload
       end
 
       def format_fallback_text(event, file)

data/lib/rigor/cli/type_scan_command.rb

@@ -12,6 +12,7 @@ require_relative "type_scan_renderer"
 require_relative "type_scan_report"
 require_relative "command"
 require_relative "probe_environment"
+require_relative "coverage_scan"
 
 module Rigor
   class CLI
@@ -70,7 +71,15 @@ module Rigor
 
       def scan_paths(paths, options)
         configuration = Configuration.load(options.fetch(:config))
-        scope = Scope.empty(environment: project_environment(configuration, paths))
+        # Same seed set as `rigor coverage` and `coverage --protection` (#502). Without it a cross-file class
+        # constant reads `Dynamic` and is counted as an unrecognised node, so the scan reports the engine as
+        # blinder than it is — on Mastodon that alone was most of a 14.7% unrecognised rate.
+        scope = CoverageScan.discovery_seeded_scope(
+          files: paths,
+          configuration: configuration,
+          environment: project_environment(configuration, paths),
+          parameter_inference: configuration.parameter_inference
+        )
         scanner = Inference::CoverageScanner.new(scope: scope)
         accumulator = ScanAccumulator.new
         paths.each { |path| scan_one(path, scanner, accumulator, configuration) }

data/lib/rigor/cli.rb

@@ -376,7 +376,7 @@ module Rigor
           check      Analyze Ruby source files
           init       Create a starter .rigor.yml
           annotate   Print FILE with each line's last-expression type
-          type-of    Print the inferred type at FILE:LINE:COL
+          type-of    Print inferred types at FILE:LINE[:COL] positions
           trace      Replay how the engine typed FILE as a terminal animation
           type-scan  Report Scope#type_of coverage across PATHs
           effects    Report each method's effect labels, and the committed effect snapshot

data/lib/rigor/configuration.rb

@@ -144,10 +144,13 @@ module Rigor
       },
       "bundler" => {
         # Open item O4 — target-project Bundler awareness. When `bundle_path:` is set (or auto-detected),
-        # Rigor walks `<bundle_path>/ruby/*/gems/*/sig/` and adds each gem-shipped sig directory to
-        # `signature_paths:`. With O7's failure-memo in place, conflicts (a vendored sig already declares the
-        # same constant) degrade gracefully to "no RBS env" with a single-line warning naming the offending
-        # file, rather than hanging.
+        # Rigor walks `<bundle_path>/ruby/*/gems/*/sig/` (RubyGems-sourced gems) and
+        # `<bundle_path>/ruby/*/bundler/gems/*/sig/` (`git:`-sourced gems) and adds each gem-shipped sig
+        # directory to `signature_paths:`. A `path:`-sourced gem is not under either — Bundler uses the
+        # `path:` directory in place rather than copying it into the bundle root — so add its `sig/` directly
+        # via `signature_paths:` instead. With O7's failure-memo in place, conflicts (a vendored sig already
+        # declares the same constant) degrade gracefully to "no RBS env" with a single-line warning naming
+        # the offending file, rather than hanging.
         #
         # `bundle_path:` (String, optional): explicit path to the bundler install root (e.g.,
         # "vendor/bundle" or an absolute path). Resolved relative to the project root (`paths:`'s base) when

data/lib/rigor/effects/plugin_facts.rb

@@ -326,7 +326,7 @@ module Rigor
         payload = [
           @labels_by_owner.sort.map { |owner, labels| [owner, labels.sort] },
           @class_rows.keys.sort_by { |singleton| singleton ? 1 : 0 }
-                          .map { |singleton| [singleton, sorted(@class_rows[singleton])] },
+                     .map { |singleton| [singleton, sorted(@class_rows[singleton])] },
           sorted(@path_rows), sorted(@self_rows), sorted(@result_rows),
           @edges.map { |edge| [edge.target.to_s, edge.receiver, edge.selector.to_s, edge.plugin_id] }.sort,
           @entry_points.map(&:to_h).sort_by { |preset| preset["name"] },

data/lib/rigor/effects/scanner.rb

@@ -107,10 +107,9 @@ module Rigor
       end
 
       def walk_namespace(node, prefix)
-        name = Source::ConstantPath.qualified_name(node.constant_path)
-        return node.rigor_each_child { |child| walk(child, prefix, false) } if name.nil?
+        nested = Source::ConstantPath.declaration_prefix(prefix, node.constant_path)
+        return node.rigor_each_child { |child| walk(child, prefix, false) } if nested.nil?
 
-        nested = prefix + [name]
         record_superclass(nested.join("::"), node, prefix) if node.is_a?(Prism::ClassNode)
         walk(node.body, nested, false) if node.body
       end

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -57,8 +57,12 @@ module Rigor
       #   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
-      #   project actually declares". Pass `nil` (the default) to keep the pre-Layer-3 behaviour of
-      #   returning every non-skipped `sig/` under the bundle.
+      #   project actually declares". A git-sourced directory carries no version to compare (see
+      #   {.gem_name_from_sig_path}), so for those the filter instead requires the matching `locked_gems`
+      #   entry to have `git_source: true` — name alone is not enough, since a gem that moved off a `git:`
+      #   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
       #   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.
@@ -72,14 +76,41 @@ module Rigor
         )
         return [] if resolved.nil?
 
-        # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig/` is the canonical bundler layout. `*` on the ruby
-        # version dir picks up whichever Ruby the bundle was installed for.
-        all = Dir.glob(resolved.join("ruby", "*", "gems", "*", "sig")).map { |d| Pathname.new(d) }
+        # Two bundler-install layouts, both under the same `ruby/X.Y.Z/` root (`*` picks up whichever Ruby
+        # the bundle was installed for):
+        #
+        # - `gems/<name>-<ver>/sig/` — the RubyGems-sourced layout, the canonical case.
+        # - `bundler/gems/<repo>-<12-hex-revision>/sig/` — `git:`-sourced gems (`Bundler::Source::Git#
+        #   install_path`); the directory name carries the git repository's basename and a 12-character
+        #   revision prefix, not the gem name or version. Before this, a fork's own `sig/` was invisible to
+        #   rigor no matter how it was authored — see issue #611.
+        #
+        # `path:`-sourced gems are NOT under either glob: Bundler does not copy them into the bundle root at
+        # all (`Bundler::Source::Path#path` is the user's own `path:` directory, used in place), so there is
+        # no bundle-relative location to walk. A `path:`-sourced gem's `sig/` is only reachable by adding it
+        # directly to the project's `signature_paths:` — which already works today and needs no discovery.
+        all = (Dir.glob(resolved.join("ruby", "*", "gems", "*", "sig")) +
+               Dir.glob(resolved.join("ruby", "*", "bundler", "gems", "*", "sig"))).map { |d| Pathname.new(d) }
         filtered = all.reject { |sig_dir| skip_gems.include?(gem_name_from_sig_path(sig_dir)) }
         return filtered if locked_gems.nil? || locked_gems.empty?
 
         expected_dirs = expected_gem_dirs(locked_gems)
-        filtered.select { |sig_dir| expected_dirs.include?(sig_dir.parent.basename.to_s) }
+        filtered.select do |sig_dir|
+          if git_sourced_layout?(sig_dir)
+            # A git install's directory name carries no resolvable version (see above), so the lockfile
+            # filter can only check the gem NAME, not `(name, version)` — but name alone is not enough: a
+            # gem that used to be `git:`-sourced and has since moved to a released version keeps its old
+            # `bundler/gems/<repo>-<sha>/` directory sitting in the bundle tree until a `bundle clean`, and
+            # its NAME is still present in the lockfile (now via the rubygems entry). Matching on name only
+            # would silently readmit that stale git install — this repo's own `vendor/bundle` had exactly
+            # this after `binpacker` moved from `git:` to a released gem. `locked_gems` must say this name is
+            # CURRENTLY git-sourced, not merely present.
+            locked = locked_gems[gem_name_from_sig_path(sig_dir)]
+            !!locked&.git_source
+          else
+            expected_dirs.include?(sig_dir.parent.basename.to_s)
+          end
+        end
       end
 
       # `{name => LockedGem}` → set of canonical bundler gem directory basenames. Pure-Ruby gems install as
@@ -98,19 +129,39 @@ module Rigor
       end
       private_class_method :expected_gem_dirs
 
-      # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig` → `<name>`. The gem directory follows the canonical
-      # `<name>-<version>` pattern; we strip everything from the last hyphen onwards to recover the name.
-      # (Platform-tagged variants like `ffi-1.17.4-aarch64-linux-gnu/` keep their platform suffix in the
-      # version part, so the first hyphen from the right is still the name boundary.)
+      # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig` → `<name>`, or
+      # `<bundle>/ruby/X.Y.Z/bundler/gems/<repo>-<12-hex-revision>/sig` → `<repo>`. The two bundler-install
+      # layouts name their gem directory differently, so which suffix to strip depends on which layout
+      # `sig_dir` came from:
+      #
+      # - rubygems layout: `<name>-<version>` (platform-tagged variants like `ffi-1.17.4-aarch64-linux-gnu/`
+      #   keep their platform suffix in the version part) — the version always starts with a digit, so strip
+      #   from the first `-` followed by a digit.
+      # - git layout: `<repo-basename>-<12-hex-char-revision>` (`Bundler::Source::Git#install_path`) — no
+      #   version at all, and the repository name need not equal the gem name (a fork hosted under a
+      #   different repo name, a monorepo). Strip the fixed-width hex suffix instead; best-effort only, since
+      #   the true gem name isn't recoverable from the filesystem without running Bundler.
       #
       # Public so the O4 Layer 3 slice-3 coverage report (`RbsCoverageReport`) can classify discovered bundle
       # sigs against locked gem names without re-running discovery.
       def self.gem_name_from_sig_path(sig_dir)
         gem_dir = sig_dir.parent.basename.to_s
-        # Strip `-<version>` and any platform suffix. The version always starts with a digit, so split at
-        # the first `-` followed by a digit.
-        gem_dir.sub(/-\d.*\z/, "")
+        if git_sourced_layout?(sig_dir)
+          gem_dir.sub(/-[0-9a-f]{12}\z/, "")
+        else
+          gem_dir.sub(/-\d.*\z/, "")
+        end
+      end
+
+      # True when `sig_dir` sits under the `bundler/gems/` (git-sourced) layout rather than the plain
+      # `gems/` (rubygems-sourced) layout — `<bundle>/ruby/X.Y.Z/bundler/gems/<dir>/sig` vs.
+      # `<bundle>/ruby/X.Y.Z/gems/<dir>/sig`. A directory-shape check, not a name-shape guess: the two glob
+      # roots in {.discover} are already disjoint, so this just recovers which one a given path came from.
+      def self.git_sourced_layout?(sig_dir)
+        gem_dir = sig_dir.parent
+        gem_dir.parent.basename.to_s == "gems" && gem_dir.parent.parent.basename.to_s == "bundler"
       end
+      private_class_method :git_sourced_layout?
 
       # Returns `Pathname` resolved bundle path, or `nil` when neither explicit nor auto-detected. Public
       # for the stats banner so end users can see what rigor picked up.

data/lib/rigor/environment/failure_slot.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Environment
+    # Issue #784 — a mutable, first-write-wins record of one shared-build failure, held by the otherwise
+    # frozen {Environment} the way {HktRegistryHolder} holds a memoised value. A lazy build that raises
+    # during per-file analysis records here at its seam instead of raising into every file's
+    # `analyze_body` rescue; the coordinator snapshots the slot after the file loop (the build is lazy, so
+    # a snapshot taken before the loop reads nothing) and the aggregator surfaces it once for the run.
+    #
+    # First-write-wins: the build is memoised, so a second failure can only be the same one re-observed.
+    #
+    # Concurrency: single-threaded use only, the same discipline as {HktRegistryHolder}.
+    class FailureSlot
+      def initialize
+        @value = nil
+      end
+
+      # @param value [Array] 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.
+      attr_reader :value
+    end
+  end
+end