rigortype 0.4.2 → 0.4.3

data/lib/rigor/cli/unused_command.rb

@@ -49,8 +49,8 @@ module Rigor
 
         configuration = Configuration.load(options.fetch(:config))
         paths = @argv.empty? ? configuration.paths : @argv
-        scan_cache = Analysis::Reachability::ScanCache.open(configuration.cache_path,
-                                                            target_ruby: configuration.target_ruby)
+        establish_root(configuration)
+        scan_cache = open_scan_cache(configuration)
         declarations, references, dynamic_uses, shadows = scan(paths, configuration, scan_cache)
         references.concat(signature_references(configuration))
         dynamic_uses.concat(template_mentions(declarations, scan_cache))
@@ -68,6 +68,47 @@ module Rigor
 
       private
 
+      # A scan's role and the spelling it records depend on the root and the working directory (#1760): a role
+      # reads every spelling below either ({#role_of}), and a relative path argument is recorded as written
+      # relative to the working directory.
+      def open_scan_cache(configuration)
+        cwd = canonical(Dir.pwd)
+        spelled = cwd == @root ? "" : ":#{cwd}"
+        Analysis::Reachability::ScanCache.open(configuration.cache_path, target_ruby: configuration.target_ruby,
+                                                                         root: "#{@root}#{spelled}")
+      end
+
+      # The root, and its spellings: the realpath and the logical directory it was named by.
+      def establish_root(configuration)
+        @root = project_root(configuration)
+        logical = @root == canonical(Dir.pwd) ? Dir.pwd : configuration.exclude_base
+        @root_spellings = [@root, File.absolute_path(logical)].uniq
+      end
+
+      # The project root (#1760), realpath'd: the config file's directory, unless the config sits below the
+      # working directory (`--config=ci/rigor.yml` from the project root), where the working directory is the
+      # project. Run from a subdirectory, or from a directory unrelated to the config, it is the config's.
+      # The root never rises above the config's directory or the working directory, so the role rules, which
+      # anchor `qa/`, `e2e/` and `features/` at the root, keep reading the project; an analysed path outside
+      # it reads as `../…`.
+      def project_root(configuration)
+        base = canonical(configuration.exclude_base)
+        cwd = canonical(Dir.pwd)
+        inside?(base, cwd) && base != cwd ? cwd : base
+      end
+
+      def inside?(path, dir)
+        path.start_with?("#{dir.chomp('/')}/")
+      end
+
+      # The directories the wider corpus is read from: the root, and the working directory when it lies
+      # outside the root. Reading the working directory too keeps the corpus no narrower than it was when
+      # the working directory alone was read; a reference only ever makes a declaration more reachable.
+      def corpus_dirs
+        cwd = canonical(Dir.pwd)
+        cwd == @root || inside?(cwd, @root) ? [@root] : [@root, cwd]
+      end
+
       def build_graph(configuration, options, contribution, declarations:, references:, dynamic_uses:, shadows:)
         Analysis::Reachability::Graph.new(
           declarations: declarations, references: references, dynamic_uses: dynamic_uses, shadows: shadows,
@@ -111,21 +152,52 @@ module Rigor
       # references resolve to first (#1732).
       # Every file is consulted every run — an unchanged one contributes its cached scan, so the
       # whole-project completeness the `--incremental` refusal protects is unaffected.
+      #
+      # A file is parsed once however it is spelled (#1760), but every spelling of it keeps what it referred
+      # to under its own path and role, exactly as when each spelling was scanned separately: dropping a
+      # spelling lost its role, and with it a production reference a `spec/` symlink to the same file would
+      # otherwise have hidden. Only the declarations are taken once, from the first analysed spelling, which
+      # is the one the report prints; any other spelling's declarations are shadows, as a wider-corpus
+      # file's are (#1732).
       def scan(paths, configuration, cache)
-        declaration_files = Analysis::PathExpansion.ruby_files(paths, configuration.exclude_patterns).to_set
-        declarations = []
-        shadows = []
-        references = []
-        dynamic_uses = []
-        (declaration_files + reference_files(paths, configuration)).sort.each do |file|
-          result = cache.serve(:scan, file) { read_and_scan(file, configuration) }
+        out = { declarations: [], references: [], dynamic_uses: [], shadows: [] }
+        file_spellings(paths, configuration).sort.each do |real, list|
+          primary, analysed = list.find { |_, declared| declared } || list.first
+          result = cache.serve(:scan, primary) { read_and_scan(primary, real, configuration) }
           next if result.nil?
 
-          (declaration_files.include?(file) ? declarations : shadows).concat(result.declarations)
-          references.concat(result.references)
-          dynamic_uses.concat(result.dynamic_uses)
+          out[analysed ? :declarations : :shadows].concat(result.declarations)
+          list.map(&:first).each { |file| add_spelling(out, result, file, real, primary) }
         end
-        [declarations, references, dynamic_uses, shadows]
+        out.values_at(:declarations, :references, :dynamic_uses, :shadows)
+      end
+
+      def add_spelling(out, result, file, real, primary)
+        out[:shadows].concat(result.declarations.map { |d| d.with(path: file) }) unless file == primary
+        role = role_of(file, real)
+        out[:references].concat(result.references.map { |r| r.with(path: file, role: role) })
+        out[:dynamic_uses].concat(result.dynamic_uses.map { |u| respelled(u, file, role) })
+      end
+
+      # `{realpath => [[spelling, analysed?], ...]}`: the analysed spellings first, in `paths:` order, then
+      # the wider corpus's.
+      def file_spellings(paths, configuration)
+        analysed = Analysis::PathExpansion.ruby_files(paths, configuration.exclude_patterns,
+                                                      base: configuration.exclude_base)
+        spellings = Hash.new { |hash, real| hash[real] = [] }
+        analysed.each { |file| spellings[canonical(file)] << [file, true] }
+        reference_files(paths, configuration).each { |file| spellings[canonical(file)] << [file, false] }
+        spellings = spellings.transform_values { |list| list.uniq(&:first) }
+        @analysed_spellings = spellings.transform_values do |list|
+          list.filter_map do |file, analysed|
+            file if analysed
+          end
+        end
+        spellings
+      end
+
+      def respelled(use, file, role)
+        use.with(path: file, role: role, site: use.site && "#{file}:#{use.line}")
       end
 
       # The reference corpus is the PROJECT, not the analysed paths. A constant declared in `lib/` is commonly
@@ -133,21 +205,80 @@ module Rigor
       # treating those as absent is what manufactured artifacts on two of three corpus targets in #345.
       # Widening the *declaration* set the same way would cancel the gain (measured: +1 / −3 / +2 candidates,
       # ADR-102 WD2), which is exactly why the two corpora are separated rather than both widened.
+      #
+      # The files are read from every {#corpus_dirs} entry (#1760): running from a subdirectory or through a
+      # symlinked spelling reads the same project.
       def reference_files(_paths, configuration)
-        relative = Analysis::Reachability::ProjectFiles.own(Dir.glob(REFERENCE_GLOB, base: Dir.pwd), Dir.pwd)
-        absolute = relative.map { |rel| File.absolute_path(rel) }
-        Analysis::PathExpansion.reject_excluded(absolute, configuration.exclude_patterns).to_set
+        absolute = project_files(REFERENCE_GLOB)
+        Analysis::PathExpansion.reject_excluded(absolute, configuration.exclude_patterns,
+                                                base: configuration.exclude_base)
       end
 
-      def read_and_scan(file, configuration)
+      # The role is read from the file's realpath relative to the project root (#1760), so `test/helper.rb`
+      # is test code whichever directory the command runs from. A file outside the root reads as `../…`,
+      # which names no directory above the root.
+      def read_and_scan(file, real, configuration)
         Analysis::Reachability::Scan.call(path: file, source: File.read(file),
                                           target_ruby: configuration.target_ruby,
-                                          root: File.absolute_path(Dir.pwd))
+                                          role: role_of(file, real))
       rescue SystemCallError
         nil
       end
 
-      # A glob is matched against the declaration's path AND its path relative to the working directory:
+      # Absolute paths of the project's own files matching `glob`, under every corpus directory.
+      def project_files(glob)
+        corpus_dirs.flat_map do |dir|
+          Analysis::Reachability::ProjectFiles.own(Dir.glob(glob, base: dir), dir).map { |rel| File.join(dir, rel) }
+        end.uniq
+      end
+
+      def canonical(path)
+        File.realpath(path)
+      rescue SystemCallError
+        File.absolute_path(path)
+      end
+
+      # A file's role (#1760), read from its spellings as written below the project root or the working
+      # directory: the first one below the root decides, and any of them reading as test code makes it test
+      # code, so a `features/` tree below a subdirectory run's working directory stays test code as it was when
+      # the working directory was the only root. The realpath is read only when no written spelling lies below
+      # either: a symlink whose target runs through a `test/` directory must not turn the production files
+      # reached through it into test code.
+      def role_of(file, real)
+        spellings = below(file, @root_spellings) + below(file, cwd_spellings)
+        spellings = below(real, @root_spellings) + below(real, cwd_spellings) if spellings.empty?
+        role_for = Analysis::Reachability::Scan.method(:role_for)
+        return :test if spellings.uniq.any? { |path| role_for.call(path) == :test }
+
+        role_for.call(spellings.first || relative_to_root(real))
+      end
+
+      # `path` relative to every directory in `dirs` it lies below.
+      def below(path, dirs)
+        absolute = File.absolute_path(path)
+        dirs.filter_map { |dir| absolute.delete_prefix("#{dir.chomp('/')}/") if inside?(absolute, dir) }.uniq
+      end
+
+      # The working directory as its realpath and, when the shell's `PWD` names it, as that logical spelling.
+      def cwd_spellings
+        @cwd_spellings ||= begin
+          logical = ENV.fetch("PWD", nil)
+          real = canonical(Dir.pwd)
+          logical && canonical(logical) == real ? [real, Dir.pwd, logical].uniq : [real, Dir.pwd].uniq
+        end
+      end
+
+      def relative_to_root(real)
+        prefix = "#{@root.chomp('/')}/"
+        return real.delete_prefix(prefix) if real.start_with?(prefix)
+
+        Pathname.new(real).relative_path_from(Pathname.new(@root)).to_s
+      rescue ArgumentError
+        real
+      end
+
+      # A glob is matched against every analysed spelling of the declaration's file, and each of them and its
+      # realpath relative to the project root (#1760) and to the working directory:
       # `configuration.paths` are expanded to absolute, so a user-written `--entry-point=lib/entry.rb` would
       # otherwise never match anything and silently produce a root set of zero.
       # A constant named only from the project's own `sig/` is referenced — the #345 probe reported exactly this
@@ -181,8 +312,8 @@ module Rigor
         names = declarations.map(&:fqn)
         return [] if names.empty?
 
-        Analysis::Reachability::ProjectFiles.own(Dir.glob(TEMPLATE_GLOB, base: Dir.pwd), Dir.pwd).flat_map do |rel|
-          absolute = File.absolute_path(rel)
+        project_files(TEMPLATE_GLOB).flat_map do |absolute|
+          rel = relative_to_root(absolute)
           haystack = cache.serve(:runs, absolute) { constant_bearing_text(File.read(absolute).scrub) }
           names.filter_map do |fqn|
             next unless haystack.include?(fqn)
@@ -213,10 +344,12 @@ module Rigor
         return [] if globs.empty?
 
         matcher = Analysis::Reachability::ProjectFiles.method(:entry_point_match?)
-        cwd = "#{File.absolute_path(Dir.pwd)}/"
         declarations.filter_map do |d|
-          relative = d.path.delete_prefix(cwd)
-          d.fqn if globs.any? { |g| matcher.call(g, d.path) || matcher.call(g, relative) }
+          real = canonical(d.path)
+          dirs = @root_spellings + cwd_spellings
+          written = @analysed_spellings.fetch(real, [d.path]) | [d.path]
+          spellings = [*written, relative_to_root(real), *written.flat_map { |w| below(w, dirs) }, *below(real, dirs)]
+          d.fqn if globs.any? { |g| spellings.any? { |path| matcher.call(g, path) } }
         end
       end
 

data/lib/rigor/cli.rb

@@ -51,6 +51,7 @@ module Rigor
       "init" => :run_init,
       "annotate" => :run_annotate,
       "type-of" => :run_type_of,
+      "lens" => :run_lens,
       "trace" => :run_trace,
       "type-scan" => :run_type_scan,
       "effects" => :run_effects,
@@ -291,18 +292,36 @@ module Rigor
 
     # The settings `rigor init` writes: the defaults, with `test_paths:` spelled out as the test roots found now, so
     # the project's config says where its tests are rather than leaving it to auto-detection. The roots are written
-    # relative to the config file's directory, which is what {Configuration.load} resolves them against.
+    # relative to the config file's directory, which is what {Configuration.load} resolves them against. `paths:`
+    # is written the same way: the default `lib` is resolved against the physical cwd, so a config written to
+    # `config/rigor.yml` must say `../lib`, or it loads back as `config/lib` (#1399).
     #
     # `target_ruby` is left out (the template writes it commented): a written key is a statement about the runtime
     # (#1692), and the starter must not make one the user never chose.
     def init_settings(path)
+      config_dir = config_dir_of(path)
       settings = Configuration::DEFAULTS.except("target_ruby")
+      settings = settings.merge("paths" => roots_relative_to(settings.fetch("paths"), config_dir))
       test_paths = Configuration.new.resolved_test_paths
       return settings if test_paths.empty?
 
-      config_dir = Pathname(File.absolute_path(File.dirname(path)))
-      relative = test_paths.map { |root| Pathname(root).relative_path_from(config_dir).to_s }
-      settings.merge("test_paths" => relative)
+      settings.merge("test_paths" => roots_relative_to(test_paths, config_dir))
+    end
+
+    # The directory the config file's roots are written relative to. An absolute `--path` is taken through its
+    # physical directory: the roots are resolved against the physical cwd (`Dir.pwd` is getcwd), so a logical
+    # spelling through a symlink makes the lexical `..` climb a different tree than the kernel does (#1399 review).
+    # A relative `--path` stays lexical, as {Configuration.load} resolves it.
+    def config_dir_of(path)
+      dir = File.dirname(path)
+      Pathname(Pathname(path).absolute? ? File.realdirpath(dir) : File.absolute_path(dir))
+    end
+
+    # Each root is resolved against the physical cwd (where `rigor` reads it from), then written relative to the config
+    # dir. With the config at the project root, both sides are the same physical directory, so the roots come out as
+    # they are spelled from it (`lib`, `spec`), which is master's output for the default config.
+    def roots_relative_to(roots, config_dir)
+      roots.map { |root| Pathname(File.absolute_path(root)).relative_path_from(config_dir).to_s }
     end
 
     def run_annotate
@@ -317,6 +336,12 @@ module Rigor
       TypeOfCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_lens
+      require_relative "cli/lens_command"
+
+      LensCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def run_trace
       require_relative "cli/trace_command"
 
@@ -463,6 +488,7 @@ module Rigor
           init       Create a starter .rigor.yml
           annotate   Print FILE with each line's last-expression type
           type-of    Print inferred types at FILE:LINE[:COL] positions
+          lens       Map a file's declarations with their types and provenance (experimental)
           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

@@ -356,6 +356,13 @@ module Rigor
         data = DEFAULTS.merge(raw)
       end
       new(autowire_default_plugins(data), effects_key_present, target_ruby_key_present || false)
+        .with_exclude_base(resolved && File.exist?(resolved) ? File.dirname(resolved) : nil)
+    end
+
+    # #1576 — the directory relative `exclude:` patterns are matched against: the directory of the config file in
+    # use (the base `paths:` resolve against), or the working directory when no config file is used.
+    def exclude_base
+      @base_dir || Dir.pwd
     end
 
     # ADR-93 WD2 — the one bundled plugin default-wired without a `plugins:` entry. `rigor-rbs-inline` is the
@@ -746,6 +753,14 @@ module Rigor
       copy.freeze
     end
 
+    # #1576 — a sibling Configuration whose relative `exclude:` patterns match against `dir` (nil: the working
+    # directory). {Configuration.load} sets it to the loaded config file's directory.
+    def with_exclude_base(dir)
+      copy = dup
+      copy.instance_variable_set(:@base_dir, dir && File.absolute_path(dir).freeze)
+      copy.freeze
+    end
+
     # #1777 — a sibling Configuration with only `baseline:` unset, every other field (including the
     # explicitness of `target_ruby`) shared with the receiver. `rigor baseline generate` analyses with
     # this so the generating run sees exactly the configuration `rigor check` will, minus the filter it

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -118,15 +118,19 @@ module Rigor
       # `{name => LockedGem}` → set of canonical bundler gem directory basenames. Pure-Ruby gems install as
       # `<name>-<version>`; platform-specific gems install as `<name>-<version>-<platform>` (e.g.
       # `ffi-1.17.4-aarch64-linux-gnu`). Lockfile platform `"ruby"` is the pure-Ruby case; any other value is
-      # treated as a platform tag.
+      # treated as a platform tag. Every locked variant contributes a directory (#1844): the set only selects
+      # among directories that are actually installed, so admitting another platform's name costs nothing,
+      # while dropping the host's would discard its `sig/`.
       def self.expected_gem_dirs(locked_gems)
         locked_gems.each_value.with_object(Set.new) do |locked, set|
-          base = "#{locked.name}-#{locked.version}"
-          set << if locked.platform == "ruby" || locked.platform.empty?
-                   base
-                 else
-                   "#{base}-#{locked.platform}"
-                 end
+          locked.variants.each do |version, platform|
+            base = "#{locked.name}-#{version}"
+            set << if platform == "ruby" || platform.empty?
+                     base
+                   else
+                     "#{base}-#{platform}"
+                   end
+          end
         end
       end
       private_class_method :expected_gem_dirs

data/lib/rigor/environment/installed_gem_set.rb

@@ -35,11 +35,12 @@ module Rigor
         found.freeze
       end
 
-      # `<bundle>/ruby/X.Y.Z/gems/<name>-<version>/` — the same pure-filesystem layout
+      # `<bundle>/ruby/X.Y.Z/gems/<name>-<version>[-<platform>]/` — 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.
+      # directory (`commonmarker-2.10.0-arm64-darwin`) is kept with its platform as a variant: those builds
+      # ship the same `lib/<name>.rb` and top-level namespace as the `ruby` one, and the index looks the
+      # directory up by that variant. A name installed more than once keeps every directory as a variant.
       def from_bundle_tree(bundle_path)
         return {} if bundle_path.nil?
 
@@ -47,10 +48,15 @@ module Rigor
         return {} unless base.directory?
 
         Dir.glob(base.join("ruby", "*", "gems", "*")).each_with_object({}) do |dir, acc|
-          name, version = split_name_version(File.basename(dir))
+          name, version, platform = split_install_dirname(File.basename(dir))
           next unless name
 
-          acc[name] ||= locked_gem(name, version)
+          prior = acc[name]
+          acc[name] = if prior
+                        prior.with(variants: [*prior.variants, [version, platform]])
+                      else
+                        locked_gem(name, version, platform)
+                      end
         end
       end
 
@@ -70,15 +76,36 @@ module Rigor
         {}
       end
 
-      def locked_gem(name, version)
-        LockfileResolver::LockedGem.new(name: name, version: version, platform: "ruby")
+      def locked_gem(name, version, platform = "ruby")
+        LockfileResolver::LockedGem.new(name: name, version: version, platform: platform)
       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)
+      # Splits a gem install directory's basename into `[name, version, platform]`, or nil. The version
+      # always starts with a digit and carries no hyphen; a platform tail is accepted only when RubyGems
+      # recognises its OS (`arm64-darwin`, `x86_64-linux-gnu`, `java`), so `foo-2fa-1.0` stays the plain gem
+      # `foo-2fa`. The platform split is tried first, because a plain split of `foo-1.0-universal-darwin-23`
+      # would claim the name `foo-1.0-universal-darwin`; and from the rightmost version-shaped segment,
+      # because RubyGems also reads `1.0-x86_64-linux` as a linux platform, which would cut
+      # `foo-2fa-1.0-x86_64-linux` at `foo`.
+      def split_install_dirname(basename)
+        platform_split(basename) || plain_split(basename)
+      end
+
+      def platform_split(basename)
+        cuts = []
+        basename.scan(/-(\d[^-]*)(?=-.)/) { cuts << Regexp.last_match }
+        cuts.reverse_each do |match|
+          platform = match.post_match.delete_prefix("-")
+          # `current` makes `Gem::Platform.new` read the host's platform, which a non-main Ractor may not touch.
+          next if platform == "current"
+          return [match.pre_match, match[1], platform] unless Gem::Platform.new(platform).os == "unknown"
+        end
+        nil
+      end
+
+      def plain_split(basename)
         match = /\A(.+)-(\d[^-]*)\z/.match(basename)
-        match ? [match[1], match[2]] : nil
+        match ? [match[1], match[2], "ruby"] : nil
       end
     end
   end

data/lib/rigor/environment/lockfile_resolver.rb

@@ -30,13 +30,29 @@ module Rigor
       # 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)
+      #
+      # `variants` is every `[version, platform]` pair the lockfile locks under this name, in Bundler's parsed
+      # order. A multi-platform lockfile (`bundle lock --add-platform`) lists one spec per platform — `ffi
+      # (1.17.4)`, `ffi (1.17.4-arm64-darwin)`, … — and Bundler installs whichever matches the host, so
+      # {BundleSigDiscovery} must admit all of them (#1844). `version` / `platform` name one representative
+      # variant for the readers that want a single version (coverage report, doctor): the `ruby` one when the
+      # lockfile has it, otherwise the last parsed. Defaults to the single `[version, platform]` pair, and the
+      # pair must be one of `variants`.
+      LockedGem = Data.define(:name, :version, :platform, :git_source, :variants) do
+        def initialize(name:, version:, platform:, git_source: false, variants: nil)
+          version = -version.to_s
+          platform = -platform.to_s
+          variants = (variants || [[version, platform]]).map { |v, p| [-v.to_s, -p.to_s].freeze }.uniq.freeze
+          unless variants.include?([version, platform])
+            raise ArgumentError, "LockedGem #{name}: [#{version}, #{platform}] is not one of its variants"
+          end
+
           super(
             name: -name.to_s,
-            version: -version.to_s,
-            platform: -platform.to_s,
-            git_source: git_source ? true : false
+            version: version,
+            platform: platform,
+            git_source: git_source ? true : false,
+            variants: variants
           )
         end
       end
@@ -162,10 +178,13 @@ module Rigor
           # `#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(
+          # A multi-platform lockfile repeats the name once per platform; fold the repeats into `variants`
+          # instead of letting the last one overwrite the rest (#1844).
+          entry = LockedGem.new(
             name: spec.name, version: spec.version.to_s, platform: platform,
             git_source: spec.source.is_a?(Bundler::Source::Git)
           )
+          h[entry.name] = (prior = h[entry.name]) ? merge_variant(prior, entry) : entry
         end
         locked.freeze
       rescue ::Ractor::IsolationError => e
@@ -177,6 +196,18 @@ module Rigor
       end
       private_class_method :do_parse
 
+      # Folds a further platform variant of an already-parsed name into it. The representative keeps a `ruby`
+      # variant once seen; otherwise the last variant wins, as it did before variants were kept.
+      def self.merge_variant(prior, entry)
+        rep = prior.platform == "ruby" ? prior : entry
+        prior.with(
+          variants: [*prior.variants, [entry.version, entry.platform]],
+          version: rep.version, platform: rep.platform,
+          git_source: prior.git_source || entry.git_source
+        )
+      end
+      private_class_method :merge_variant
+
       # #1064 — Bundler's lockfile parser reads RubyGems module state a non-main Ractor may not touch, so the
       # parse raises `Ractor::IsolationError` there whatever the lockfile says. That is an engine constraint, not
       # a malformed lockfile, and the warning must not send the user to fix a file that is fine. The Ractor pool

data/lib/rigor/environment/missing_gem_constant_index.rb

@@ -37,8 +37,8 @@ module Rigor
     module MissingGemConstantIndex
       module_function
 
-      # @param gems — `[gem_name, version]` pairs (the `:missing` rows of
-      #   {RbsCoverageReport}).
+      # @param gems — `[gem_name, version, variants]` entries (the `:missing` rows of {RbsCoverageReport},
+      #   with the gem's `LockedGem#variants`); `variants` may be omitted or nil, meaning the `ruby` one.
       # @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).
@@ -49,8 +49,9 @@ module Rigor
         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}"] || git_dirs[gem_name] || spec_resolver.call(gem_name, version)
+        gems.each do |gem_name, version, variants|
+          dir = bundle_dir(bundle_dirs, gem_name, version, variants) ||
+                git_dirs[gem_name] || spec_resolver.call(gem_name, version)
           next unless dir
 
           entry_files(dir, gem_name).each do |file|
@@ -62,9 +63,8 @@ module Rigor
 
       # `{"<name>-<version>" => gem_dir}` for the target's bundle, or `{}` when no bundle is resolvable. The
       # 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.
+      # git-sourced layout is {.git_gem_dirs}'s. Keyed on the dir basename, which {.bundle_dir} reconstructs
+      # per locked variant.
       def bundle_gem_dirs(bundle_path)
         return {} if bundle_path.nil?
 
@@ -76,6 +76,21 @@ module Rigor
         end
       end
 
+      # The installed directory of one of the gem's locked variants: `<name>-<version>` for the `ruby` one,
+      # `<name>-<version>-<platform>` for a platform-tagged one. Bundler installs only the variant matching
+      # the host, and a multi-platform lockfile's representative is usually the `ruby` one, so every variant
+      # is tried. A platform-tagged gem is not a native-only gem: the commonmarker, nokogiri and sqlite3 builds
+      # each ship `lib/<name>.rb` declaring the gem's top-level namespace, exactly as the `ruby` build does.
+      def bundle_dir(bundle_dirs, gem_name, version, variants)
+        [[version, "ruby"], *variants].each do |variant_version, platform|
+          basename = "#{gem_name}-#{variant_version}"
+          basename = "#{basename}-#{platform}" unless platform == "ruby"
+          dir = bundle_dirs[basename]
+          return dir if dir
+        end
+        nil
+      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

data/lib/rigor/environment/rbs_loader.rb

@@ -2321,6 +2321,39 @@ module Rigor
         [].freeze
       end
 
+      # Issue #1752 — the lookup of `class_name`'s class object as RBS declares it, the singleton twin of
+      # {#ancestor_names_for}: `[:singleton, name]` for each singleton class on it (`C`'s, then each superclass's)
+      # and `[:instance, name]` for each module or class whose instance methods it reaches (the declared `extend`s,
+      # then `Class`, `Module`, `Object`, `Kernel` and `BasicObject` for a class, `Module` onwards for a module), in
+      # lookup order. A refinement of `Object` or `Module` answers a call on a class object through the second kind.
+      #
+      # Marked as an internal demand, as {#ancestor_names_for} is (issue #696). Memoised per name: the environment is
+      # immutable for the loader's lifetime.
+      #
+      # @return `::`-stripped pairs, or `[]` for an unknown class and on any RBS build error.
+      def singleton_ancestors_for(class_name)
+        key = class_name.to_s.delete_prefix("::")
+        memo = (@state[:singleton_ancestors] ||= {})
+        return memo[key] if memo.key?(key)
+
+        memo[key] = build_singleton_ancestors(key)
+      end
+
+      def build_singleton_ancestors(key)
+        during_internal_demand do
+          definition = singleton_definition(key)
+          next [].freeze if definition.nil?
+
+          definition.ancestors.ancestors.map do |ancestor|
+            kind = ancestor.is_a?(::RBS::Definition::Ancestor::Singleton) ? :singleton : :instance
+            [kind, ancestor.name.to_s.delete_prefix("::")].freeze
+          end.uniq.freeze
+        end
+      rescue ::RBS::BaseError, StandardError
+        [].freeze
+      end
+      private :build_singleton_ancestors
+
       # @return the class method on `class_name`. For example,
       #   `singleton_method(class_name: "Integer", method_name: :sqrt)` returns the definition for
       #   `Integer.sqrt`, while `singleton_method(class_name: "Foo", method_name: :new)` returns Class#new

data/lib/rigor/environment/required_features.rb

@@ -51,7 +51,8 @@ module Rigor
       #
       # @param sources — path => source text, read in place of that path's file (an editor buffer).
       def for_configuration(configuration, extra_files = [], sources: {})
-        files = Analysis::PathExpansion.ruby_files(configuration.paths, configuration.exclude_patterns)
+        files = Analysis::PathExpansion.ruby_files(configuration.paths, configuration.exclude_patterns,
+                                                   base: configuration.exclude_base)
         scan(files + Array(extra_files).map(&:to_s), sources: sources)
       rescue StandardError
         []
@@ -77,7 +78,8 @@ module Rigor
       # @return path (absolute) => the features that file requires, for every file under the configured paths
       #   that requires any. A long-lived reader (the language server) keeps this and overlays its open buffers.
       def feature_files(configuration)
-        listed = Analysis::PathExpansion.ruby_files(configuration.paths, configuration.exclude_patterns)
+        listed = Analysis::PathExpansion.ruby_files(configuration.paths, configuration.exclude_patterns,
+                                                    base: configuration.exclude_base)
         files = listed.map { |path| File.expand_path(path.to_s) }
         result = files.each_with_object({}) do |path, acc|
           features = memoized_features_in(path)