rigortype 0.4.0 → 0.4.2

data/lib/rigor/cli/effects_report.rb

@@ -121,7 +121,7 @@ module Rigor
       # syntax: this is the argument a shell just tab-completed, and `rigor effects app/models` meaning
       # "that directory" is the only reading a reader would guess.
       def self.normalize_scope(scope)
-        Array(scope).map { |path| File.expand_path(path.to_s.chomp("/")) }.freeze
+        Array(scope).map { |path| File.absolute_path(path.to_s.chomp("/")) }.freeze
       end
       private_class_method :normalize_scope
 
@@ -130,7 +130,7 @@ module Rigor
         return false if paths.nil? || paths.empty?
 
         paths.any? do |path|
-          absolute = File.expand_path(path)
+          absolute = File.absolute_path(path)
           roots.any? { |root| absolute == root || absolute.start_with?("#{root}/") }
         end
       end

data/lib/rigor/cli/trace_command.rb

@@ -69,7 +69,12 @@ module Rigor
       def execute(file:, options:)
         configuration = Configuration.load(options.fetch(:config))
         source = File.read(file, encoding: Encoding::UTF_8)
+        # Prism parses the ORIGINAL bytes, so a `# -*- coding: -*-` file is read in its own encoding. Only the text the
+        # renderer sees is scrubbed: the colouriser and line splitter raise on a byte invalid in UTF-8 (a comment,
+        # `__END__` data, a non-UTF-8 file).
+        # Scrubbing is byte-for-byte (`?` per bad byte), so Prism's positions still address it.
         parse_result = Prism.parse(source, filepath: file, version: configuration.target_ruby)
+        source = source.scrub { |bytes| "?" * bytes.bytesize } unless source.valid_encoding?
         return 1 if parse_errors?(parse_result, file)
 
         events = record_events(parse_result.value, file, configuration)

data/lib/rigor/cli/type_of_command.rb

@@ -87,7 +87,7 @@ module Rigor
       # 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)
+        environment = project_environment(targets.map(&:file).uniq, configuration, buffer)
         base_scope = Scope.empty(environment: environment)
 
         results_by_target = Array.new(targets.length)
@@ -218,8 +218,10 @@ 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(files, configuration)
-        ProjectEnvironment.build(configuration: configuration, source_files: files)
+      # Issue #1700 — an editor buffer is scanned for required features in place of the file it stands for.
+      def project_environment(files, configuration, buffer = nil)
+        ProjectEnvironment.build(configuration: configuration, source_files: files,
+                                 feature_sources: ProjectEnvironment.buffer_sources(buffer))
       end
 
       def file_exists?(file)

data/lib/rigor/cli/unused_command.rb

@@ -51,7 +51,7 @@ module Rigor
         paths = @argv.empty? ? configuration.paths : @argv
         scan_cache = Analysis::Reachability::ScanCache.open(configuration.cache_path,
                                                             target_ruby: configuration.target_ruby)
-        declarations, references, dynamic_uses = scan(paths, configuration, scan_cache)
+        declarations, references, dynamic_uses, shadows = scan(paths, configuration, scan_cache)
         references.concat(signature_references(configuration))
         dynamic_uses.concat(template_mentions(declarations, scan_cache))
 
@@ -59,7 +59,8 @@ module Rigor
                                                                    cache_store: cache_store(configuration))
         references.concat(plugin_references(contribution.references))
         graph = build_graph(configuration, options, contribution,
-                            declarations: declarations, references: references, dynamic_uses: dynamic_uses)
+                            declarations: declarations, references: references, dynamic_uses: dynamic_uses,
+                            shadows: shadows)
         emit(graph.report, options, supply: root_supply(contribution.roots, declarations))
         scan_cache.save
         0
@@ -67,9 +68,9 @@ module Rigor
 
       private
 
-      def build_graph(configuration, options, contribution, declarations:, references:, dynamic_uses:)
+      def build_graph(configuration, options, contribution, declarations:, references:, dynamic_uses:, shadows:)
         Analysis::Reachability::Graph.new(
-          declarations: declarations, references: references, dynamic_uses: dynamic_uses,
+          declarations: declarations, references: references, dynamic_uses: dynamic_uses, shadows: shadows,
           root_fqns: root_fqns(declarations, options.fetch(:entry_points)) + contribution.roots,
           foreign: foreign_predicate(configuration)
         )
@@ -106,22 +107,25 @@ module Rigor
       end
 
       # Declarations come from the analysed paths; references additionally from the wider corpus (WD7).
+      # A wider-corpus file's own declarations come back as shadows: never nodes, only what that file's own
+      # 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.
       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) }
           next if result.nil?
 
-          declarations.concat(result.declarations) if declaration_files.include?(file)
+          (declaration_files.include?(file) ? declarations : shadows).concat(result.declarations)
           references.concat(result.references)
           dynamic_uses.concat(result.dynamic_uses)
         end
-        [declarations, references, dynamic_uses]
+        [declarations, references, dynamic_uses, shadows]
       end
 
       # The reference corpus is the PROJECT, not the analysed paths. A constant declared in `lib/` is commonly
@@ -131,13 +135,14 @@ module Rigor
       # ADR-102 WD2), which is exactly why the two corpora are separated rather than both widened.
       def reference_files(_paths, configuration)
         relative = Analysis::Reachability::ProjectFiles.own(Dir.glob(REFERENCE_GLOB, base: Dir.pwd), Dir.pwd)
-        absolute = relative.map { |rel| File.expand_path(rel) }
+        absolute = relative.map { |rel| File.absolute_path(rel) }
         Analysis::PathExpansion.reject_excluded(absolute, configuration.exclude_patterns).to_set
       end
 
       def read_and_scan(file, configuration)
         Analysis::Reachability::Scan.call(path: file, source: File.read(file),
-                                          target_ruby: configuration.target_ruby)
+                                          target_ruby: configuration.target_ruby,
+                                          root: File.absolute_path(Dir.pwd))
       rescue SystemCallError
         nil
       end
@@ -177,7 +182,7 @@ module Rigor
         return [] if names.empty?
 
         Analysis::Reachability::ProjectFiles.own(Dir.glob(TEMPLATE_GLOB, base: Dir.pwd), Dir.pwd).flat_map do |rel|
-          absolute = File.expand_path(rel)
+          absolute = File.absolute_path(rel)
           haystack = cache.serve(:runs, absolute) { constant_bearing_text(File.read(absolute).scrub) }
           names.filter_map do |fqn|
             next unless haystack.include?(fqn)
@@ -208,7 +213,7 @@ module Rigor
         return [] if globs.empty?
 
         matcher = Analysis::Reachability::ProjectFiles.method(:entry_point_match?)
-        cwd = "#{File.expand_path(Dir.pwd)}/"
+        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) }
@@ -235,6 +240,7 @@ module Rigor
       def foreign_predicate(configuration)
         env = Environment.for_project(libraries: configuration.libraries, signature_paths: [],
                                       cache_store: cache_store(configuration),
+                                      required_features: ProjectEnvironment.required_features(configuration),
                                       **ProjectEnvironment.dependency_discovery_options(configuration))
         ->(fqn) { !env.singleton_for_name(fqn).nil? }
       rescue StandardError

data/lib/rigor/cli.rb

@@ -281,6 +281,10 @@ module Rigor
         # tempfile, uri, logger, date, prism, rbs). Adding a
         # `sig/<gem>.rbs` file under `sig/` is the simplest way
         # to extend type coverage today.
+        #
+        # `target_ruby` is left commented: the default only picks the syntax Rigor parses. Set it to the lowest
+        # Ruby your project runs on, and Rigor also reports what that Ruby deprecates.
+        # target_ruby: #{Configuration::DEFAULTS.fetch('target_ruby').dump}
         #{YAML.dump(init_settings(path)).sub(/\A---\n/, '')}
       YAML
     end
@@ -288,13 +292,17 @@ 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.
+    #
+    # `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)
+      settings = Configuration::DEFAULTS.except("target_ruby")
       test_paths = Configuration.new.resolved_test_paths
-      return Configuration::DEFAULTS if test_paths.empty?
+      return settings if test_paths.empty?
 
-      config_dir = Pathname(File.expand_path(File.dirname(path)))
+      config_dir = Pathname(File.absolute_path(File.dirname(path)))
       relative = test_paths.map { |root| Pathname(root).relative_path_from(config_dir).to_s }
-      Configuration::DEFAULTS.merge("test_paths" => relative)
+      settings.merge("test_paths" => relative)
     end
 
     def run_annotate

data/lib/rigor/config_audit.rb

@@ -2,6 +2,7 @@
 
 require "did_you_mean"
 
+require_relative "config_path"
 require_relative "signature_path_audit"
 # ADR-87 WD4 — only the pure rule-id table (`ALL_RULES` / `RULE_FAMILIES`) is needed, so require the light
 # `rule_ids.rb` rather than the engine-pulling `check_rules.rb`; keeps `config_audit` (loaded by every check)
@@ -199,14 +200,14 @@ module Rigor
     end
 
     def self.add_missing_dir(warnings, path, project_root, kind, key)
-      return if path.nil? || File.directory?(File.expand_path(path, project_root))
+      return if path.nil? || File.directory?(ConfigPath.absolute(path, project_root))
 
       warnings << Warning.new(kind: kind, message: "#{key}: #{path.inspect} is not a directory",
                               fields: { "path" => path })
     end
 
     def self.add_missing_file(warnings, path, project_root, kind, key)
-      return if path.nil? || File.file?(File.expand_path(path, project_root))
+      return if path.nil? || File.file?(ConfigPath.absolute(path, project_root))
 
       warnings << Warning.new(kind: kind, message: "#{key}: #{path.inspect} does not exist", fields: { "path" => path })
     end

data/lib/rigor/config_path.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rigor
+  # Resolves a path-valued setting that a person wrote into `.rigor.yml`, or that Bundler wrote into its
+  # own config (`BUNDLE_PATH: "~/gems"`), to an absolute path.
+  #
+  # A leading `~/` and a bare `~` expand to the invoking user's home directory — exactly what
+  # `File.expand_path` does for those two spellings, and what Bundler itself does for `BUNDLE_PATH`. Every
+  # other spelling goes through `File.absolute_path`, so `~drafts/x` stays a directory named `~drafts`
+  # instead of `File.expand_path`'s home-of-user-`drafts` reading, which raises `ArgumentError` for a user
+  # that does not exist (#1510). It never raises on a `~`.
+  #
+  # Paths the analysis is *given to analyse* (CLI path arguments, template units, the runner's file sets)
+  # do not use this: the shell has already expanded a `~` there, so a surviving one is a directory name.
+  module ConfigPath
+    HOME_PREFIX = %r{\A~(?=/|\z)}
+
+    # `base_dir` anchors a relative result and defaults to the working directory.
+    def self.absolute(path, base_dir = nil)
+      text = path.to_s
+      return File.absolute_path(text, base_dir) unless text.match?(HOME_PREFIX)
+
+      home = Dir.home
+      File.absolute_path(text.sub(HOME_PREFIX, home), base_dir)
+    rescue ArgumentError
+      File.absolute_path(text, base_dir)
+    end
+  end
+end

data/lib/rigor/configuration/severity_profile.rb

@@ -38,6 +38,10 @@ module Rigor
           "call.argument-type-mismatch" => :warning,
           "call.possible-nil-receiver" => :warning,
           "call.raise-non-exception" => :warning,
+          # Issue #1692 — the code runs on the stated Ruby (it warns, and breaks only at the removal version), so the
+          # rule takes the slot of the rules that report working-but-wrong code: `flow.unreachable-branch`'s
+          # info / warning / error. It runs only under an explicit `target_ruby` of 4.1 or later.
+          "call.deprecated-ruby2-keywords" => :info,
           "flow.always-raises" => :warning,
           "flow.unreachable-branch" => :info,
           "flow.dead-assignment" => :info,
@@ -100,6 +104,7 @@ module Rigor
           "call.argument-type-mismatch" => :error,
           "call.possible-nil-receiver" => :error,
           "call.raise-non-exception" => :error,
+          "call.deprecated-ruby2-keywords" => :warning,
           "flow.always-raises" => :error,
           "flow.unreachable-branch" => :warning,
           "flow.dead-assignment" => :warning,
@@ -141,6 +146,7 @@ module Rigor
           "call.argument-type-mismatch" => :error,
           "call.possible-nil-receiver" => :error,
           "call.raise-non-exception" => :error,
+          "call.deprecated-ruby2-keywords" => :error,
           "flow.always-raises" => :error,
           "flow.unreachable-branch" => :error,
           "flow.dead-assignment" => :error,
@@ -210,7 +216,12 @@ module Rigor
         profile_table.fetch(rule, authored_severity)
       end
 
+      # A family name has no `.` in it, so only a dot-free key can match one. `resolve` runs for every
+      # diagnostic in a run's stream, and most configurations carry no such key (usually no overrides at all),
+      # so the split below is skipped for them rather than allocating a name that nothing can match.
       def family_override(rule, overrides)
+        return nil unless overrides.any? { |key, _| !key.to_s.include?(".") }
+
         family = rule.split(".").first
         return nil if family.nil?
 

data/lib/rigor/configuration.rb

@@ -6,6 +6,7 @@ require_relative "bleeding_edge"
 require_relative "ci_detector"
 require_relative "configuration/dependencies"
 require_relative "configuration/severity_profile"
+require_relative "config_path"
 require_relative "configuration_error"
 require_relative "effects/entry_points"
 require_relative "effects/label"
@@ -282,6 +283,23 @@ module Rigor
                 :effects_snapshot_path, :effects_snapshot_reach, :effects_snapshot_gate, :effects_tolerated,
                 :effects_labels, :effects_attribution, :effects_envelopes
 
+    # ADR-47 WD5 amendment (#1692) — whether `.rigor.yml` (or its `includes:` chain) set `target_ruby:` itself.
+    # The default `"4.0"` is a parse version, not something the user said about the Ruby the project runs on.
+    def target_ruby_explicit?
+      @target_ruby_explicit
+    end
+
+    # ADR-47 WD5 amendment (#1692) — `target_ruby` read as a user statement about the runtime: the configured
+    # version when the user set it explicitly, nil when it is the default or `"latest"`. `"latest"` names the
+    # newest syntax this Prism build parses, which moves with a Rigor upgrade, so it states no runtime. Only the
+    # Ruby-deprecation rules read this; `Inference::VersionGuard` keeps the analyzer's own `RUBY_VERSION`.
+    def stated_runtime_ruby
+      return nil unless target_ruby_explicit?
+      return nil if target_ruby == "latest"
+
+      target_ruby
+    end
+
     # ADR-103 WD13 — whether effect collection runs. True exactly when the loaded configuration carried an
     # `effects:` block, whatever its body; `rigor effects` enables it for its own run by loading an
     # implicit `effects: {}` instead of by consulting anything else. Nothing else — no annotation, no
@@ -307,7 +325,7 @@ module Rigor
     def resolved_test_paths(root: Dir.pwd)
       return test_paths unless test_paths.nil?
 
-      CONVENTIONAL_TEST_PATHS.map { |dir| File.expand_path(dir, root) }.select { |dir| File.directory?(dir) }
+      CONVENTIONAL_TEST_PATHS.map { |dir| File.absolute_path(dir, root) }.select { |dir| File.directory?(dir) }
     end
 
     # Loads a configuration file.
@@ -326,6 +344,7 @@ module Rigor
       if resolved.nil? || !File.exist?(resolved)
         data = DEFAULTS
         effects_key_present = false
+        target_ruby_key_present = false
       else
         # ADR-103 WD15 — captured from the RAW, pre-`DEFAULTS.merge` file (+ its `includes:` chain) because
         # `DEFAULTS` itself carries an `"effects" => false` entry: once merged, "the file never wrote
@@ -333,9 +352,10 @@ module Rigor
         # indistinguishable to {#initialize}. This is the only place that distinction still exists.
         raw = load_with_includes(resolved)
         effects_key_present = raw.key?("effects")
+        target_ruby_key_present = raw.key?("target_ruby")
         data = DEFAULTS.merge(raw)
       end
-      new(autowire_default_plugins(data), effects_key_present)
+      new(autowire_default_plugins(data), effects_key_present, target_ruby_key_present || false)
     end
 
     # ADR-93 WD2 — the one bundled plugin default-wired without a `plugins:` entry. `rigor-rbs-inline` is the
@@ -404,7 +424,7 @@ module Rigor
     # the include-aware load before applying `--treat-all-as-inline-rbs`'s plugin injection (see
     # {CLI::CheckCommand#load_check_configuration}).
     def self.load_with_includes(path, visited: Set.new)
-      absolute = File.expand_path(path)
+      absolute = File.absolute_path(path)
       raise ConfigurationError, "circular include: #{absolute}" if visited.include?(absolute)
 
       raw = read_yaml(absolute)
@@ -433,7 +453,7 @@ module Rigor
 
       accumulated = {}
       includes.each do |inc|
-        inc_path = File.expand_path(inc.to_s, base_dir)
+        inc_path = ConfigPath.absolute(inc.to_s, base_dir)
         unless File.exist?(inc_path)
           raise ConfigurationError, "include not found: #{inc.inspect} (referenced from #{base_dir})"
         end
@@ -459,7 +479,7 @@ module Rigor
     def self.resolve_path_key!(out, key, base_dir)
       return unless out.key?(key) && !out[key].nil?
 
-      out[key] = Array(out[key]).map { |p| File.expand_path(p.to_s, base_dir) }
+      out[key] = Array(out[key]).map { |p| ConfigPath.absolute(p.to_s, base_dir) }
     end
 
     def self.resolve_plugins_io_paths!(out, base_dir)
@@ -467,7 +487,7 @@ module Rigor
       return unless plugins_io.is_a?(Hash) && plugins_io["allowed_paths"]
 
       duped = plugins_io.dup
-      duped["allowed_paths"] = Array(plugins_io["allowed_paths"]).map { |p| File.expand_path(p.to_s, base_dir) }
+      duped["allowed_paths"] = Array(plugins_io["allowed_paths"]).map { |p| ConfigPath.absolute(p.to_s, base_dir) }
       out["plugins_io"] = duped
     end
 
@@ -518,7 +538,13 @@ module Rigor
     #   `"key" => value` hash literal — this class's usual call shape, all over the spec suite — is coerced
     #   into keyword arguments by Ruby whenever the method declares ANY keyword parameter, which would break
     #   every `Configuration.new("some_key" => value)` call site with an "unknown keyword" `ArgumentError`.
-    def initialize(data = DEFAULTS, effects_key_present = data.key?("effects"))
+    # @param target_ruby_key_present — ADR-47 WD5 amendment (#1692) — whether the file set `target_ruby:` itself,
+    #   captured before `DEFAULTS.merge` for the same reason as `effects_key_present` and positional for the same
+    #   reason. See {#stated_runtime_ruby}. The default reads the key off `data`, which is right only for a hash that
+    #   has not been through `DEFAULTS.merge` (DEFAULTS carries the key); a caller that merges passes it explicitly.
+    #   The bare `Configuration.new` is not explicit.
+    def initialize(data = DEFAULTS, effects_key_present = data.key?("effects"),
+                   target_ruby_key_present = data.key?("target_ruby") && !data.equal?(DEFAULTS))
       # Record before the per-key fetches below discard the evidence. Top level only, deliberately —
       # see {ConfigAudit.unknown_key_warnings} for why a nested check cannot key on DEFAULTS.
       @unknown_keys = (data.keys.map(&:to_s) - KNOWN_KEYS).sort.freeze
@@ -527,6 +553,7 @@ module Rigor
       plugins_io = DEFAULTS.fetch("plugins_io").merge(data.fetch("plugins_io", {}))
 
       @target_ruby = coerce_target_ruby(data.fetch("target_ruby", DEFAULTS.fetch("target_ruby")))
+      @target_ruby_explicit = target_ruby_key_present ? true : false
       @paths = Array(data.fetch("paths", DEFAULTS.fetch("paths"))).map(&:to_s).freeze
       user_excludes = Array(data.fetch("exclude", DEFAULTS.fetch("exclude"))).map(&:to_s)
       @exclude_patterns = (BUILTIN_EXCLUDES + user_excludes).uniq.freeze
@@ -618,6 +645,9 @@ module Rigor
     def to_h # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       {
         "target_ruby" => target_ruby,
+        # A stated `target_ruby` turns on the deprecation rules a defaulted one leaves off (#1692), so the run cache
+        # key and the incremental fingerprint must tell the two apart even where the value matches.
+        "target_ruby_explicit" => target_ruby_explicit?,
         "paths" => paths,
         "exclude" => exclude_patterns - BUILTIN_EXCLUDES,
         "plugins" => plugins,
@@ -716,6 +746,21 @@ module Rigor
       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
+    # is about to replace; rebuilding from a key list let each unlisted key revert to its default.
+    #
+    # Same frozen `dup` shape as {#with_bleeding_edge}. `@baseline_path` is the only ivar
+    # `#initialize` derives from the `baseline:` key.
+    def without_baseline
+      return self if baseline_path.nil?
+
+      copy = dup
+      copy.instance_variable_set(:@baseline_path, nil)
+      copy.freeze
+    end
+
     # ADR-103 WD14 — the ad-hoc opt-in `rigor effects` uses when the project's configuration carries no
     # `effects:` block: a sibling Configuration with an implicit empty block, every other field shared.
     # A configuration that already enables effects is returned unchanged, so a project's own settings

data/lib/rigor/effects/plugin_facts.rb

@@ -311,12 +311,12 @@ module Rigor
       # `[class_name, …ancestors]`, memoised per class. Cycle-guarded and capped: the tables are *as
       # written*, so a project can spell an ancestry that loops.
       #
-      # Included and prepended modules are walked beside the superclass, nearer first, because that is
-      # Ruby's own lookup order and because a framework's contract is as often a module as a base class:
-      # a Sidekiq worker is `class TriggerWebhookWorker; include Sidekiq::Job`, with no base class at all,
-      # so a superclass-only walk could not match a row about it however the plugin spelled one (#456).
-      # `ExpressionTyper#enqueue_ancestors` already resolves a self-call this way; the two tables
-      # disagreeing about what an ancestor is was the bug.
+      # Included and prepended modules are walked beside the superclass, nearer first, because a framework's
+      # contract is as often a module as a base class: a Sidekiq worker is `class TriggerWebhookWorker;
+      # include Sidekiq::Job`, with no base class at all, so a superclass-only walk could not match a row
+      # about it however the plugin spelled one (#456). Breadth-first is close to Ruby's lookup order but not
+      # it (a module an included module includes comes after the superclass here); `Scope::ResolutionChain`
+      # is the exact order, and this walk over the plugin facts' own copy of the tables does not read it yet.
       def ancestry(class_name)
         @ancestry[class_name] ||= begin
           chain = []

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -2,6 +2,8 @@
 
 require "yaml"
 
+require_relative "../config_path"
+
 module Rigor
   class Environment
     # Target-project Bundler awareness (O4, implemented).
@@ -167,7 +169,7 @@ module Rigor
       # for the stats banner so end users can see what rigor picked up.
       def self.resolve_bundle_path(bundle_path:, project_root: Dir.pwd, auto_detect: true, home: nil)
         if bundle_path
-          path = Pathname.new(File.expand_path(bundle_path.to_s, project_root))
+          path = Pathname.new(Rigor::ConfigPath.absolute(bundle_path.to_s, project_root))
           return path if path.directory?
 
           return nil
@@ -203,7 +205,7 @@ module Rigor
       # read of the real `~/.bundle/config`).
       def self.auto_detect(project_root:, home: nil)
         from_config = read_bundle_config_path(File.join(project_root, ".bundle", "config"))
-        return File.expand_path(from_config, project_root) if from_config
+        return Rigor::ConfigPath.absolute(from_config, project_root) if from_config
 
         vendor = File.join(project_root, "vendor", "bundle")
         return vendor if File.directory?(vendor)
@@ -221,7 +223,7 @@ module Rigor
         configured = read_bundle_config_path(File.join(home, ".bundle", "config"))
         return nil unless configured
 
-        resolved = File.expand_path(configured, project_root)
+        resolved = Rigor::ConfigPath.absolute(configured, project_root)
         File.directory?(resolved) ? resolved : nil
       end
       private_class_method :global_bundle_path

data/lib/rigor/environment/gated_signature_guard.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rbs"
+
+module Rigor
+  class Environment
+    # Issue #1700 — the type names a {RequiredFeatures}-gated vendored directory declares, which
+    # `RbsLoader.gated_trouble` builds in its trial to decide whether the directory may stay in an environment.
+    # Read off the vendored files themselves: a nested `class Prime; class EratosthenesGenerator` names
+    # `Prime::EratosthenesGenerator`, and a reopened core class (`class Integer`) is named too, since a clash
+    # there fails `Integer`'s own definition.
+    module GatedSignatureGuard
+      module_function
+
+      # @param dir — the vendored directory (Pathname).
+      # @return the absolute-less names (`"Prime::PseudoPrimeGenerator"`) of every class and module it declares.
+      def type_names(dir)
+        Dir.glob(File.join(dir.to_s, "*.rbs")).flat_map do |file|
+          _, _, decls = RBS::Parser.parse_signature(File.read(file))
+          names(decls, nil)
+        rescue RBS::BaseError, SystemCallError
+          []
+        end.uniq
+      end
+
+      def names(decls, namespace)
+        decls.flat_map do |decl|
+          next [] unless decl.is_a?(RBS::AST::Declarations::Class) || decl.is_a?(RBS::AST::Declarations::Module)
+
+          name = qualify(namespace, decl.name)
+          [name] + names(decl.members, name)
+        end
+      end
+
+      def qualify(namespace, type_name)
+        text = type_name.to_s
+        return text.delete_prefix("::") if text.start_with?("::") || namespace.nil?
+
+        "#{namespace}::#{text}"
+      end
+    end
+  end
+end