rigortype 0.3.6 → 0.3.8

data/lib/rigor/environment/lockfile_resolver.rb

@@ -22,13 +22,19 @@ module Rigor
       #
       # `version` is the resolved version string (e.g. "8.0.1"); `platform` is the lockfile's platform tag,
       # normalised to `"ruby"` when the lockfile records `ruby` and to the raw String otherwise (e.g.
-      # "aarch64-linux-gnu").
-      LockedGem = Data.define(:name, :version, :platform) do
-        def initialize(name:, version:, platform:)
+      # "aarch64-linux-gnu"). `git_source` is true when the lockfile's `GIT` stanza (rather than `GEM`)
+      # resolved this gem — see {BundleSigDiscovery}, which needs it to tell a genuine git install apart
+      # from a same-named gem the bundle tree has an out-of-band `bundler/gems/` leftover for (e.g. a
+      # dependency that moved from a `git:` source to a released version without a `bundle clean`, so its
+      # git-installed directory is still sitting there under the OLD source's name). Defaults `false` so
+      # existing callers that construct a `LockedGem` without an opinion stay conservative.
+      LockedGem = Data.define(:name, :version, :platform, :git_source) do
+        def initialize(name:, version:, platform:, git_source: false)
           super(
             name: -name.to_s,
             version: -version.to_s,
-            platform: -platform.to_s
+            platform: -platform.to_s,
+            git_source: git_source ? true : false
           )
         end
       end
@@ -94,8 +100,12 @@ module Rigor
           # (references/rbs/sig/shims/bundler.rbs) does NOT declare `LazySpecification#platform` so the call
           # site needs a suppression marker.
           platform = spec.platform.to_s # rigor:disable undefined-method
+          # `#source` is the `Bundler::Source::*` this spec resolved from — `Git` for a `GIT` lockfile
+          # stanza, `Rubygems` for a `GEM` one, `Path`/`Gemspec` for `path:`. Only `Git` sources land under
+          # {BundleSigDiscovery}'s `bundler/gems/` walk.
           h[spec.name.to_s] = LockedGem.new(
-            name: spec.name, version: spec.version.to_s, platform: platform
+            name: spec.name, version: spec.version.to_s, platform: platform,
+            git_source: spec.source.is_a?(Bundler::Source::Git)
           )
         end
         locked.freeze

data/lib/rigor/environment/missing_gem_constant_index.rb

@@ -47,9 +47,10 @@ module Rigor
       #   (external gem without RBS) is true under either owner.
       def build(gems, bundle_path: nil, spec_resolver: method(:installed_gem_dir))
         bundle_dirs = bundle_gem_dirs(bundle_path)
+        git_dirs = git_gem_dirs(bundle_path)
         index = {}
         gems.each do |gem_name, version|
-          dir = bundle_dirs["#{gem_name}-#{version}"] || spec_resolver.call(gem_name, version)
+          dir = bundle_dirs["#{gem_name}-#{version}"] || git_dirs[gem_name] || spec_resolver.call(gem_name, version)
           next unless dir
 
           entry_files(dir, gem_name).each do |file|
@@ -60,9 +61,10 @@ module Rigor
       end
 
       # `{"<name>-<version>" => gem_dir}` for the target's bundle, or `{}` when no bundle is resolvable. The
-      # glob mirrors {BundleSigDiscovery}: `<bundle>/ruby/X.Y.Z/gems/<name>-<version>/`. Keyed on the dir
-      # basename so a platform-tagged variant (`ffi-1.17.4-aarch64-linux-gnu`) simply doesn't match a
-      # `<name>-<version>` lookup — those gems ship native code, not the pure-Ruby constants this indexes.
+      # glob covers the RUBYGEMS-sourced layout only, `<bundle>/ruby/X.Y.Z/gems/<name>-<version>/`; the
+      # git-sourced layout is {.git_gem_dirs}'s. Keyed on the dir basename so a platform-tagged variant
+      # (`ffi-1.17.4-aarch64-linux-gnu`) simply doesn't match a `<name>-<version>` lookup — those gems ship
+      # native code, not the pure-Ruby constants this indexes.
       def bundle_gem_dirs(bundle_path)
         return {} if bundle_path.nil?
 
@@ -74,6 +76,45 @@ module Rigor
         end
       end
 
+      # Issue #763 — `{gem_name => gem_dir}` for the target's GIT-sourced gems,
+      # `<bundle>/ruby/X.Y.Z/bundler/gems/<repo>-<12-hex-revision>/`. Before this, a `git:`-sourced gem was
+      # invisible to the index, so every constant reaching into it recorded the generic engine-gap cause
+      # where the honest story is add-RBS — the same mislabelling #530 measures from two other directions.
+      #
+      # Keyed on the name read from the directory's `*.gemspec` FILENAME, not on the directory basename: a
+      # git install's directory carries the repository name, which need not equal the gem name (a fork
+      # hosted under a different repo name, a gem inside a monorepo). No gem code is loaded — this is the
+      # filename, not an evaluated gemspec. A directory with no gemspec, or more than one, contributes
+      # nothing rather than a guess.
+      #
+      # Deliberately NOT gated on the lockfile's `git_source` the way {BundleSigDiscovery} is, and the
+      # difference is worth stating because the two look like the same problem. There, a stale
+      # `bundler/gems/` directory left behind by a gem that moved to a released version made the loader
+      # load the WRONG SIGNATURES, collapsing the RBS environment. Here the index's whole output is a gem
+      # NAME, so reading a stale checkout of the same gem yields the same answer; and the rubygems lookup
+      # is consulted FIRST in {.build}, so a gem now installed from RubyGems never reaches this map at all.
+      def git_gem_dirs(bundle_path)
+        return {} if bundle_path.nil?
+
+        base = Pathname.new(bundle_path)
+        return {} unless base.directory?
+
+        Dir.glob(base.join("ruby", "*", "bundler", "gems", "*")).each_with_object({}) do |dir, acc|
+          name = gemspec_gem_name(dir)
+          acc[name] ||= dir if name
+        end
+      end
+
+      # The gem name a checkout declares, from the single `*.gemspec` at its root, or nil when there is not
+      # exactly one. Bundler requires a git-sourced gem to ship one, so "not exactly one" means this is not
+      # the shape we think it is — and a guess from the directory basename is what this exists to avoid.
+      def gemspec_gem_name(dir)
+        specs = Dir.glob(File.join(dir, "*.gemspec"))
+        return nil unless specs.size == 1
+
+        File.basename(specs.first, ".gemspec")
+      end
+
       # RubyGems spec metadata lookup — the gem's on-disk source root, without loading any of its code.
       # Exact-version first, any-version fallback. See the class note on why this is only a fallback.
       def installed_gem_dir(name, version)

data/lib/rigor/environment/rbs_hierarchy.rb

@@ -41,32 +41,26 @@ module Rigor
         end
       end
 
+      # Issue #696 review, second pass — the ancestry lookup moved to {RbsLoader#ancestor_names_for}, and
+      # what moved with it is the reason.
+      #
+      # This method used to fetch `Cache::RbsClassAncestorTable` DIRECTLY, bypassing the loader's own
+      # accessor, and branch on `loader.cache_store`: a whole-universe table build with a store, a
+      # single-class demand without one. Same project, same question, three different answers to "which
+      # classes failed to build" — 504 on a cold store, 0 on a warm one, 2 with no store. On the DEFAULT
+      # `--workers=0` path nothing pre-warms the store, so the cold answer was the one written into the
+      # run-result cache and replayed until a file changed.
+      #
+      # The cache-state branch still exists — it is worth 50x on the warm path — but it lives behind the
+      # loader now, where both of its sides are marked as RIGOR'S OWN demand. Ordering two classes is not
+      # the analysis asking whether either one's methods resolve, so neither side reaches the diagnostic,
+      # and the answer is identical on both (the table's producer computes exactly this, keyed the same
+      # way). What this method keeps is its own per-name memo, which is about repeated comparisons.
       def ancestor_names(class_name)
         key = normalize_name(class_name)
         return @ancestor_names_cache[key] if @ancestor_names_cache.key?(key)
 
-        @ancestor_names_cache[key] =
-          if loader.cache_store
-            ancestor_table.fetch(key, [].freeze)
-          else
-            compute_ancestor_names(key)
-          end
-      end
-
-      def compute_ancestor_names(key)
-        definition = loader.instance_definition(key)
-        return [].freeze if definition.nil?
-
-        definition.ancestors.ancestors.map { |ancestor| normalize_name(ancestor.name.to_s) }.uniq.freeze
-      rescue StandardError
-        [].freeze
-      end
-
-      def ancestor_table
-        @ancestor_table ||= begin
-          require_relative "../cache/rbs_class_ancestor_table"
-          Cache::RbsClassAncestorTable.fetch(loader: loader, store: loader.cache_store)
-        end
+        @ancestor_names_cache[key] = loader.ancestor_names_for(key)
       end
 
       def normalize_name(name)