rigortype 0.4.3 → 0.4.5

data/lib/rigor/config_audit.rb

@@ -3,6 +3,7 @@
 require "did_you_mean"
 
 require_relative "config_path"
+require_relative "flow_contribution/conflict"
 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)
@@ -26,11 +27,13 @@ module Rigor
   #
   # Every check is held to the same bar that {SignaturePathAudit} set: it mirrors the
   # loader's own acceptance test, so a warning means the loader really did load nothing, and
-  # it never fires on a setup that works. In particular the rule-token check only flags a
-  # token under a built-in family (`call`, `flow`, …) — a plugin- or `rbs_extended.*` rule id
-  # (whose family Rigor cannot statically enumerate, since a `node_rule` block emits any
-  # `rule:` string it likes) is left alone, so disabling a plugin rule is never mistaken for
-  # a typo.
+  # it never fires on a setup that works. The rule-token checks lean on the reach of `disable:`
+  # and `severity_overrides:` being enumerable (issues #1953, #1985): a plugin's row answers only
+  # to its qualified `plugin.<id>.<rule>` id (or `plugin.<id>`), so a bare plugin rule there is
+  # inert (see {.disable_token_warning}, {.override_key_warning}). A `plugin.`-qualified token is
+  # checked only against `plugins:`, and a token under a non-check engine family
+  # (`rbs_extended.*`, `rbs.*`, `dynamic.*`) is left alone, since the engine emits those ids
+  # outside the catalogue.
   module ConfigAudit
     # One config-level finding. `kind` discriminates the source key (`:signature_path`,
     # `:bundled_plugin_signature_path`, `:library`, `:disabled_rule`, `:severity_override`,
@@ -146,31 +149,169 @@ module Rigor
       []
     end
 
-    # `disable:` tokens and `severity_overrides:` keys that name no rule. Restricted to
-    # tokens under a built-in family so a plugin rule id is never mis-flagged (see the module
-    # docstring).
+    # `disable:` tokens that reach no row ({.disable_token_warning}) and `severity_overrides:` keys
+    # that reach none ({.override_key_warning}).
     def self.rule_token_warnings(configuration)
+      plugin_ids = configured_plugin_ids(configuration.plugins)
       disable = Array(configuration.disabled_rules).filter_map do |token|
-        next unless inert_builtin_token?(token.to_s)
-
-        Warning.new(
-          kind: :disabled_rule,
-          message: "disable: #{token.to_s.inspect} is not a recognized rule id; the suppression has no effect",
-          fields: { "token" => token.to_s }
-        )
+        disable_token_warning(token.to_s, plugin_ids)
       end
       overrides = configuration.severity_overrides.keys.filter_map do |key|
-        next unless inert_builtin_token?(key.to_s)
-
-        Warning.new(
-          kind: :severity_override,
-          message: "severity_overrides: #{key.to_s.inspect} is not a recognized rule id; the override has no effect",
-          fields: { "token" => key.to_s }
-        )
+        override_key_warning(key.to_s, plugin_ids)
       end
       disable + overrides
     end
 
+    # Issue #1985 — the plugin loader's own rows, which a `severity_overrides:` key names by their qualified
+    # id; they also answer to the bare `load-error` / `runtime-error`.
+    PLUGIN_LOADER_ROWS = %w[plugin_loader.load-error plugin_loader.runtime-error].freeze
+    private_constant :PLUGIN_LOADER_ROWS
+
+    # A warning for a `severity_overrides:` key that can reach no row, or nil. Mirrors {.disable_token_warning}
+    # (issue #1985): a plugin's row answers only to its qualified `plugin.<id>.<rule>` or `plugin.<id>`, so a
+    # `plugin.`-qualified key naming an unconfigured plugin, and any key outside the built-in vocabulary that is
+    # not a qualified plugin id (a plugin's bare rule included), is inert. A reserved run-level row is the home of
+    # this map, so naming one is never flagged; `all` is not a family wildcard here, so it is.
+    def self.override_key_warning(key, plugin_ids)
+      reason = override_key_problem(key, plugin_ids)
+      return nil if reason.nil?
+
+      Warning.new(kind: :severity_override, message: "severity_overrides: #{key.inspect} #{reason}",
+                  fields: { "token" => key })
+    end
+
+    def self.override_key_problem(key, plugin_ids)
+      return "is not a recognized rule id; the override has no effect" if key == "all"
+      return nil unless Array(Analysis::CheckRules.resolve_rule_token(key)).empty?
+
+      if key.start_with?(Analysis::CheckRules::PLUGIN_FAMILY_PREFIX)
+        return nil if plugin_ids.nil? || plausible_plugin_token?(key, plugin_ids)
+
+        "names no plugin `plugins:` configures; the override has no effect"
+      elsif key.start_with?("plugin_loader.")
+        "is not a recognized rule id; the override has no effect" unless PLUGIN_LOADER_ROWS.include?(key)
+      elsif inert_builtin_token?(key)
+        "is not a recognized rule id; the override has no effect"
+      elsif !non_check_engine_token?(key) && !severity_only_id?(key)
+        "is not a recognized rule id; the override has no effect " \
+          "(if this is a plugin's rule, write it as `plugin.<id>.<rule>`)"
+      end
+    end
+    private_class_method :override_key_problem
+
+    # Issue #1953 — the run-level rows the diagnostic policy keeps on `severity_overrides:` and the
+    # baseline. `disable:` does not reach them by any spelling, so naming one there is inert.
+    RESERVED_RUN_LEVEL_FAMILIES = %w[plugin_loader plugin_trust rbs.coverage dynamic.dependency-source].freeze
+    RESERVED_RUN_LEVEL_IDS = %w[load-error runtime-error pool-degraded].freeze
+    private_constant :RESERVED_RUN_LEVEL_FAMILIES, :RESERVED_RUN_LEVEL_IDS
+
+    # A warning for a `disable:` token that can reach no row, or nil. Since issue #1953 the list's
+    # reach is exactly enumerable for three shapes, and those are what this flags:
+    #
+    # - a token naming a reserved run-level row ({RESERVED_RUN_LEVEL_FAMILIES} /
+    #   {RESERVED_RUN_LEVEL_IDS}), which the list never reaches;
+    # - a `plugin.`-qualified token naming no plugin `plugins:` configures — checked only when
+    #   every entry's manifest id is known without loading it ({.configured_plugin_ids});
+    # - any other token that is not `all`, a family, a legacy alias or a catalogue / `pre-eval.*`
+    #   id. A bare id never reaches a plugin's row, so a plugin's bare rule is inert here too.
+    #
+    # A token under a non-check engine family (`rbs_extended.*`, `rbs.*`, `dynamic.*`) or a known
+    # non-catalogue engine id stays unflagged: under-warning is this module's FP-safe direction.
+    def self.disable_token_warning(token, plugin_ids)
+      return nil if effective_disable_token?(token)
+
+      reason = disable_token_problem(token, plugin_ids)
+      return nil if reason.nil?
+
+      Warning.new(kind: :disabled_rule, message: "disable: #{token.inspect} #{reason}",
+                  fields: { "token" => token })
+    end
+
+    def self.disable_token_problem(token, plugin_ids)
+      if reserved_run_level_token?(token)
+        "names a run-level row, which `disable:` does not reach; use `severity_overrides:` or a baseline"
+      elsif token.start_with?(Analysis::CheckRules::PLUGIN_FAMILY_PREFIX)
+        unless plugin_ids.nil? || plausible_plugin_token?(token, plugin_ids)
+          "names no plugin `plugins:` configures; the suppression has no effect"
+        end
+      elsif inert_builtin_token?(token)
+        "is not a recognized rule id; the suppression has no effect"
+      elsif !non_check_engine_token?(token)
+        "is not a recognized rule id; the suppression has no effect " \
+          "(if this is a plugin's rule, write it as `plugin.<id>.<rule>`)"
+      end
+    end
+    private_class_method :disable_token_problem
+
+    def self.effective_disable_token?(token)
+      return true if token == "all"
+
+      !Array(Analysis::CheckRules.resolve_rule_token(token)).empty?
+    end
+    private_class_method :effective_disable_token?
+
+    def self.reserved_run_level_token?(token)
+      RESERVED_RUN_LEVEL_IDS.include?(token) ||
+        RESERVED_RUN_LEVEL_FAMILIES.any? { |family| token == family || token.start_with?("#{family}.") }
+    end
+    private_class_method :reserved_run_level_token?
+
+    # Bare ids that a `severity_overrides:` key re-stamps but a marker or `disable:` cannot suppress: the `--explain`
+    # `fallback` row and the `contribution_merge` conflict reasons (`FlowContribution::CONFLICT_VALID_REASONS`,
+    # kebab-cased). They are not in `CheckRules::NON_CHECK_DIAGNOSTIC_IDS`, which would silence the warnings for a
+    # `disable:` token or marker naming them. `spec/rigor/config_audit_spec.rb` pins this list's completeness.
+    CONFLICT_IDS = FlowContribution::CONFLICT_VALID_REASONS.map { |reason| reason.to_s.tr("_", "-").freeze }.freeze
+    SEVERITY_ONLY_IDS = (%w[fallback] + CONFLICT_IDS).freeze
+    private_constant :CONFLICT_IDS, :SEVERITY_ONLY_IDS
+
+    def self.severity_only_id?(key)
+      SEVERITY_ONLY_IDS.include?(key)
+    end
+    private_class_method :severity_only_id?
+
+    def self.non_check_engine_token?(token)
+      Analysis::CheckRules::NON_CHECK_DIAGNOSTIC_IDS.include?(token) ||
+        Analysis::CheckRules::NON_CHECK_DIAGNOSTIC_FAMILIES.include?(token.split(".").first)
+    end
+    private_class_method :non_check_engine_token?
+
+    # `plugin.<id>` or `plugin.<id>.<rule>` for a configured id. A manifest id may itself hold a
+    # dot, so the token is matched against each id rather than split.
+    def self.plausible_plugin_token?(token, plugin_ids)
+      rest = token.delete_prefix(Analysis::CheckRules::PLUGIN_FAMILY_PREFIX)
+      plugin_ids.any? { |id| rest == id || rest.start_with?("#{id}.") }
+    end
+    private_class_method :plausible_plugin_token?
+
+    # The manifest id of every `plugins:` entry, or nil when one cannot be known without loading
+    # the plugin. An explicit `id:` is the id; a bundled plugin's id is its gem name minus the
+    # `rigor-` prefix ({Plugin::FirstParty}); a third-party gem named without `id:` may register
+    # any id, so its presence turns the plugin-token check off. An `enabled: false` entry counts:
+    # the user has found the plugin, and under-warning is the FP-safe direction.
+    def self.configured_plugin_ids(plugins)
+      Array(plugins).each_with_object(Set.new) do |raw, ids|
+        entry = raw.is_a?(Hash) ? raw.to_h { |key, value| [key.to_s, value] } : { "gem" => raw.to_s }
+        if entry["id"]
+          ids << entry["id"].to_s
+        elsif bundled_plugin_gem?(entry["gem"].to_s)
+          ids << entry["gem"].to_s.delete_prefix(BUNDLED_GEM_PREFIX)
+        else
+          return nil
+        end
+      end
+    end
+    private_class_method :configured_plugin_ids
+
+    BUNDLED_GEM_PREFIX = "rigor-"
+    private_constant :BUNDLED_GEM_PREFIX
+
+    def self.bundled_plugin_gem?(gem)
+      return false unless gem.start_with?(BUNDLED_GEM_PREFIX)
+
+      File.file?(File.join(SignaturePathAudit::BUNDLED_PLUGINS_ROOT, gem, "lib", "#{gem}.rb"))
+    end
+    private_class_method :bundled_plugin_gem?
+
     # True when `token` looks like a built-in rule id but matches none — its first segment
     # is a built-in family yet it is neither a bare family wildcard nor a known canonical id.
     # A token whose family is not built-in (a plugin / `rbs_extended.*` rule, or a bare

data/lib/rigor/configuration/dependencies.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../configuration_error"
+
 module Rigor
   class Configuration
     # Parsed `dependencies:` section of `.rigor.yml`. Per
@@ -56,7 +58,7 @@ module Rigor
       # Hash with `source_inference:` and / or `budget_per_gem:` / `budget_overrun_strategy:` present.
       def self.from_h(data)
         return new([]) if data.nil?
-        raise ArgumentError, "dependencies: must be a Hash, got #{data.inspect}" unless data.is_a?(Hash)
+        raise ConfigurationError, "dependencies: must be a Hash, got #{data.inspect}" unless data.is_a?(Hash)
 
         raw_entries = coerce_source_inference(data["source_inference"])
         entries, warnings = dedupe_entries(raw_entries)
@@ -139,7 +141,7 @@ module Rigor
           return [] if value.nil? || value == false
 
           unless value.is_a?(Array)
-            raise ArgumentError,
+            raise ConfigurationError,
                   "dependencies.source_inference: must be a list of entries " \
                   "(or false / omitted to disable), got #{value.inspect}"
           end
@@ -149,7 +151,7 @@ module Rigor
 
         def coerce_entry(raw)
           unless raw.is_a?(Hash)
-            raise ArgumentError,
+            raise ConfigurationError,
                   "dependencies.source_inference[] entry must be a Hash, got #{raw.inspect}"
           end
 
@@ -162,7 +164,7 @@ module Rigor
 
         def coerce_gem(value)
           unless value.is_a?(String) && !value.empty?
-            raise ArgumentError,
+            raise ConfigurationError,
                   "dependencies.source_inference[].gem must be a non-empty String, got #{value.inspect}"
           end
 
@@ -170,28 +172,34 @@ module Rigor
         end
 
         def coerce_mode(value)
-          mode = (value || "when_missing").to_sym
+          mode = config_symbol(value || "when_missing")
           return mode if VALID_MODES.include?(mode)
 
-          raise ArgumentError,
+          raise ConfigurationError,
                 "dependencies.source_inference[].mode must be one of " \
                 "#{VALID_MODES.inspect}, got #{value.inspect}"
         end
 
+        # The Symbol a String / Symbol value names, or nil for any other YAML shape (a number, a list, a mapping), which
+        # the caller then reports as not one of its valid values rather than crashing on `#to_sym`.
+        def config_symbol(value)
+          value.to_sym if value.is_a?(String) || value.is_a?(Symbol)
+        end
+
         def coerce_roots(raw)
           roots = Array(raw.fetch("roots", DEFAULT_ROOTS)).map(&:to_s).freeze
           return roots unless roots.empty?
 
-          raise ArgumentError,
+          raise ConfigurationError,
                 "dependencies.source_inference[].roots must not be empty when supplied " \
                 "(omit the key to fall back to the default #{DEFAULT_ROOTS.inspect})"
         end
 
         def coerce_budget_overrun_strategy(value)
-          symbol = value.to_sym
+          symbol = config_symbol(value)
           return symbol if VALID_BUDGET_OVERRUN_STRATEGIES.include?(symbol)
 
-          raise ArgumentError,
+          raise ConfigurationError,
                 "dependencies.budget_overrun_strategy must be one of " \
                 "#{VALID_BUDGET_OVERRUN_STRATEGIES.inspect}, got #{value.inspect}"
         end
@@ -201,13 +209,13 @@ module Rigor
         # MIN_BUDGET_PER_GEM .. MAX_BUDGET_PER_GEM (i.e. 0.25× – 4× of the default).
         def coerce_budget_per_gem(value)
           unless value.is_a?(Integer)
-            raise ArgumentError,
+            raise ConfigurationError,
                   "dependencies.budget_per_gem must be an Integer, " \
                   "got #{value.inspect}"
           end
 
           unless value.between?(MIN_BUDGET_PER_GEM, MAX_BUDGET_PER_GEM)
-            raise ArgumentError,
+            raise ConfigurationError,
                   "dependencies.budget_per_gem must be in the range " \
                   "#{MIN_BUDGET_PER_GEM}..#{MAX_BUDGET_PER_GEM}, " \
                   "got #{value.inspect}"

data/lib/rigor/configuration/severity_profile.rb

@@ -202,11 +202,17 @@ module Rigor
       #   always wins) and *above* the profile table. Exact rule ids only — the overlay never carries family
       #   wildcards. Empty while the overlay is unpopulated, so the default leaves resolution bit-for-bit
       #   unchanged.
+      # @param qualified_rule — the row's `<source_family>.<rule>` id (`plugin_loader.load-error`); equal to `rule`
+      #   for a built-in row. Issue #1985 — an override key may spell it.
+      # @param plugin_family — `plugin.<id>` for a row a plugin emitted, nil for every other row. Such a row answers
+      #   to an override only by its `qualified_rule` or this whole-plugin key, never by its bare `rule` or a family
+      #   wildcard: plugins share bare rules (`load-error`), and a bare key would re-stamp them all.
       # @return the resolved severity. Returns `:off` to mean "drop the diagnostic entirely".
-      def resolve(rule:, authored_severity:, profile: DEFAULT_PROFILE, overrides: {}, bleeding_edge_overrides: {})
+      def resolve(rule:, authored_severity:, profile: DEFAULT_PROFILE, overrides: {}, bleeding_edge_overrides: {},
+                  qualified_rule: rule, plugin_family: nil)
         return authored_severity if rule.nil?
 
-        override = overrides[rule] || family_override(rule, overrides)
+        override = row_override(rule, qualified_rule, plugin_family, overrides)
         return override.to_sym if override
 
         bleeding = bleeding_edge_overrides[rule]
@@ -216,6 +222,18 @@ module Rigor
         profile_table.fetch(rule, authored_severity)
       end
 
+      # Issue #1985 — the `severity_overrides:` entry a row answers to, or nil. A plugin's row: its qualified id, then
+      # its `plugin.<id>`. Any other row: its qualified id (the plugin loader's
+      # `plugin_loader.load-error`), then its bare rule, then a family wildcard. The qualified key is the more specific
+      # one, so it wins over the bare key, as it does for a plugin's row.
+      def row_override(rule, qualified_rule, plugin_family, overrides)
+        return overrides[qualified_rule] || overrides[plugin_family] unless plugin_family.nil?
+
+        overrides[qualified_rule] || overrides[rule] || family_override(rule, overrides)
+      end
+
+      private_class_method :row_override
+
       # 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.

data/lib/rigor/configuration.rb

@@ -8,6 +8,7 @@ require_relative "configuration/dependencies"
 require_relative "configuration/severity_profile"
 require_relative "config_path"
 require_relative "configuration_error"
+require_relative "rooted_glob"
 require_relative "effects/entry_points"
 require_relative "effects/label"
 require_relative "effects/method_key"
@@ -995,9 +996,34 @@ module Rigor
     # this entry" so a templated `**` pattern in a fresh project doesn't generate an error per match-less
     # pattern.
     def expand_pre_eval_entries(entries)
-      entries.flat_map do |entry|
-        glob_pattern?(entry) ? Dir.glob(entry, sort: true) : [entry]
-      end.uniq.freeze
+      entries.flat_map { |entry| expand_pre_eval_entry(entry) }.uniq.freeze
+    end
+
+    # #1956 — a relative entry arrives joined onto the config file's directory, so the metacharacters the
+    # check above sees may be that directory's own (`ds [x]/`). The leading run of segments that name existing
+    # directories is read literally and only the rest is globbed under it: a literal entry under such a
+    # directory stays a literal path, and a pattern matches what it matches under a plain directory.
+    def expand_pre_eval_entry(entry)
+      return [entry] unless glob_pattern?(entry)
+
+      base, pattern = literal_directory_prefix(entry)
+      return [entry] unless glob_pattern?(pattern)
+
+      base ? RootedGlob.glob(base, pattern) : Dir.glob(entry, sort: true)
+    end
+
+    def literal_directory_prefix(entry)
+      segments = entry.split("/")
+      count = (1...segments.size).take_while { |n| File.directory?(join_segments(segments.take(n))) }.size
+      return [nil, entry] if count.zero?
+
+      [join_segments(segments.take(count)), segments.drop(count).join("/")]
+    end
+
+    # `"/a".split("/")` leads with an empty segment, which spells the filesystem root.
+    def join_segments(segments)
+      path = segments.join("/")
+      path.empty? ? "/" : path
     end
 
     def glob_pattern?(path)

data/lib/rigor/effects/signature_sources.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../rooted_glob"
+
 module Rigor
   module Effects
     # Everything an effect envelope may be written in, as `[buffer name, RBS source]` pairs
@@ -55,7 +57,7 @@ module Rigor
       # @param signature_paths — the configured roots; empty / nil takes the default.
       # @param virtual_rbs — the loader's virtual entries.
       def collect(signature_paths:, virtual_rbs: nil)
-        files = roots(signature_paths).flat_map { |root| Dir.glob(File.join(root.to_s, "**", "*.rbs")).sort }
+        files = roots(signature_paths).flat_map { |root| RootedGlob.glob(root, "**/*.rbs").sort }
         sources = files.filter_map do |path|
           [path, File.read(path)]
         rescue StandardError

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -3,6 +3,7 @@
 require "yaml"
 
 require_relative "../config_path"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -91,8 +92,8 @@ module Rigor
         # 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) }
+        all = (RootedGlob.glob(resolved, "ruby/*/gems/*/sig") +
+               RootedGlob.glob(resolved, "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?
 

data/lib/rigor/environment/gated_signature_guard.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rbs"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -15,7 +16,7 @@ module Rigor
       # @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|
+        RootedGlob.glob(dir, "*.rbs").flat_map do |file|
           _, _, decls = RBS::Parser.parse_signature(File.read(file))
           names(decls, nil)
         rescue RBS::BaseError, SystemCallError

data/lib/rigor/environment/gated_signature_plan.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rbs"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -132,7 +133,7 @@ module Rigor
       end
 
       def signature_files(roots)
-        roots.flat_map { |root| Dir.glob(File.join(root.to_s, "*.rbs")).sort }
+        roots.flat_map { |root| RootedGlob.glob(root, "*.rbs").sort }
       end
 
       def shell_buffer

data/lib/rigor/environment/installed_gem_set.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "lockfile_resolver"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -47,7 +48,7 @@ module Rigor
         base = Pathname.new(bundle_path)
         return {} unless base.directory?
 
-        Dir.glob(base.join("ruby", "*", "gems", "*")).each_with_object({}) do |dir, acc|
+        RootedGlob.glob(base, "ruby/*/gems/*").each_with_object({}) do |dir, acc|
           name, version, platform = split_install_dirname(File.basename(dir))
           next unless name
 

data/lib/rigor/environment/missing_gem_constant_index.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -71,7 +72,7 @@ module Rigor
         base = Pathname.new(bundle_path)
         return {} unless base.directory?
 
-        Dir.glob(base.join("ruby", "*", "gems", "*")).each_with_object({}) do |dir, acc|
+        RootedGlob.glob(base, "ruby/*/gems/*").each_with_object({}) do |dir, acc|
           acc[File.basename(dir)] ||= dir
         end
       end
@@ -114,7 +115,7 @@ module Rigor
         base = Pathname.new(bundle_path)
         return {} unless base.directory?
 
-        Dir.glob(base.join("ruby", "*", "bundler", "gems", "*")).each_with_object({}) do |dir, acc|
+        RootedGlob.glob(base, "ruby/*/bundler/gems/*").each_with_object({}) do |dir, acc|
           name = gemspec_gem_name(dir)
           acc[name] ||= dir if name
         end
@@ -124,7 +125,7 @@ module Rigor
       # 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"))
+        specs = RootedGlob.glob(dir, "*.gemspec")
         return nil unless specs.size == 1
 
         File.basename(specs.first, ".gemspec")

data/lib/rigor/environment/rbs_loader.rb

@@ -10,6 +10,7 @@ require_relative "member_consistency"
 require_relative "required_features"
 require_relative "gated_signature_guard"
 require_relative "gated_signature_plan"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -66,6 +67,15 @@ module Rigor
       QUARANTINE_WARN_LIMIT = 10
 
       class << self
+        # Issue #1902 — the fixed total order that picks ONE detail tuple for a class out of several: its two
+        # sides in {#report_definition_build_failure}, or a fresh and a replayed record in
+        # {Analysis::Runner::PoolCoordinator}. Content-only (the tuple carries no side), so both places choose
+        # the same tuple from the same candidates, whatever order those candidates arrived in.
+        def definition_build_detail_order(detail)
+          _, error_class, member, buffers, unresolved = detail
+          [error_class.to_s, member.to_s, Array(buffers).map(&:to_s), Array(unresolved).map(&:to_s)]
+        end
+
         def default
           @default ||= new.freeze
         end
@@ -540,7 +550,7 @@ module Rigor
             path = Pathname(path) unless path.is_a?(Pathname)
             next [] unless path.directory?
 
-            Dir.glob(path.join("**", "*.rbs")).map { |p| File.expand_path(p) }
+            RootedGlob.glob(path, "**/*.rbs").map { |p| File.expand_path(p) }
           end.to_set
         end
 
@@ -1907,6 +1917,25 @@ module Rigor
         (@state[:definition_build_failures] || []).dup.freeze
       end
 
+      # Issue #1929 — re-ask for `class_name`'s definition on behalf of a PREVIOUS run's analysis, which
+      # demanded it and found it failing. An `--incremental` recheck replays that run's failures, and one
+      # whose conflicting buffer is a file the recheck re-synthesized cannot be replayed as it stands (the
+      # edit may have fixed it), while the file that demanded the class may sit outside the recheck's
+      # closure and never ask again. Re-asking here re-derives the answer over the current signatures: a
+      # class that still fails is reported with its current tuple, one that now builds is not.
+      #
+      # A real demand, not {#during_internal_demand}: it stands in for the analysis's own, which is what
+      # #696 binds the reported set to. Both sides are asked, since the replayed tuple does not record which
+      # side the analysis demanded ({#report_definition_build_failure} builds both anyway).
+      #
+      # @return the class's current tuple, or nil when it now builds.
+      def redemand_definition(class_name)
+        key = class_name.to_s.delete_prefix("::")
+        instance_definition(key)
+        singleton_definition(key)
+        definition_build_failures.find { |failure| failure.first == key }
+      end
+
       # Virtual (inline-synthesized) contributions dropped by the collision quarantine
       # ({.resolve_quarantining_virtual_collisions}): buffer names absent from the built env even though the
       # entry's content is non-empty and parses (a parse failure is the synthesizer's own WD6 skip, reported
@@ -2471,6 +2500,18 @@ module Rigor
         # fail-soft: a broken RBS environment yields no entries.
       end
 
+      # ADR-113 — the RBS declaration of the constant `name` (qualified) as `[type, buffer name]`, or nil when no
+      # signature declares it. `rigor lens` reports the declared type with the provenance the buffer names.
+      def constant_declaration(name)
+        rbs_name = parse_type_name(name)
+        entry = rbs_name && env&.constant_decls&.[](rbs_name)
+        return nil unless entry
+
+        [entry.decl.type.to_s, entry.decl.location&.buffer&.name.to_s]
+      rescue ::RBS::BaseError
+        nil
+      end
+
       # Slice A constant-value lookup. Returns the translated `Rigor::Type` for a non-class constant
       # declaration (`BUCKETS: Array[Symbol]`, `DEFAULT_PATH: String`, ...) or `nil` when no constant entry
       # exists for `name` in the loaded RBS environment. Callers MUST treat the return value as authoritative
@@ -2904,15 +2945,16 @@ module Rigor
       #
       # So the rescue only remembers, keyed by the `::`-stripped name (the eager walk spells it `::Acme`,
       # a dispatch site spells it `Acme`, and they are one class — the {#synthesized_namespaces}
-      # convention), and {#report_definition_build_failure} decides. First writer wins: the instance and
-      # singleton sides fail for the same underlying collision, and the first is the one a caller hit.
+      # convention), and {#report_definition_build_failure} decides. Every side's detail is kept, not the
+      # first one written (issue #1902): the instance and singleton sides can fail for DIFFERENT reasons
+      # (a duplicated `def self.s` and a duplicated `def i` on one class), and which side a run demands first
+      # depends on which files it analysed, so first-writer-wins made the reported tuple — and with it the
+      # message's "First failure", advice and file list — differ between a cold run and a warm recheck.
       def store_definition_build_detail(class_name, error)
         key = class_name.to_s.delete_prefix("::")
-        details = (@state[:definition_build_details] ||= {})
-        return if details.key?(key)
-
-        details[key] = [key, error.class.name.to_s, definition_build_member(error),
-                        definition_build_conflict_buffers(error), unresolved_type_name_detail(error)].freeze
+        details = ((@state[:definition_build_details] ||= {})[key] ||= [])
+        details << [key, error.class.name.to_s, definition_build_member(error),
+                    definition_build_conflict_buffers(error), unresolved_type_name_detail(error)].freeze
       end
 
       # Issue #997 — the `RBS::NoTypeFoundError` twin of {#definition_build_member}: `nil` for every other
@@ -2987,14 +3029,28 @@ module Rigor
         return if details.nil?
 
         key = class_name.to_s.delete_prefix("::")
-        detail = details[key]
-        return if detail.nil?
+        return if details[key].nil?
 
         reported = (@state[:definition_build_reported] ||= {})
         return if reported[key]
 
         reported[key] = true
-        (@state[:definition_build_failures] ||= []) << detail
+        attempt_both_definition_sides(class_name)
+        canonical = details[key].min_by { |candidate| self.class.definition_build_detail_order(candidate) }
+        (@state[:definition_build_failures] ||= []) << canonical
+      end
+
+      # Issue #1902 — a reported class's tuple is chosen from BOTH sides' failures, so the side this demand
+      # did not ask for is built here too. Without it, the candidate set would be whatever sides the run
+      # happened to demand, and a recheck whose closure touches only `Berry.s` would report the singleton
+      # side's reason where the full run, which also demanded `Berry.new.i`, reported the instance side's.
+      # An internal demand: it decides WHICH reason is shown for a class the analysis already demanded, never
+      # WHETHER a class is reported, so the set #696 binds to the analysis's own demand is unchanged.
+      def attempt_both_definition_sides(class_name)
+        during_internal_demand do
+          instance_definition(class_name)
+          singleton_definition(class_name)
+        end
       end
 
       # Marks a definition demand that is RIGOR'S OWN, not the analysed program's, so