rigortype 0.4.6 → 0.4.7

data/lib/rigor/plugin.rb

@@ -21,14 +21,12 @@ require_relative "plugin/first_party"
 module Rigor
   module Plugin
     @registered = {}
-    # ADR-88 WD4b — process-global map `gem name (String) => [registered plugin id, ...]`, recorded by the
-    # loader the FIRST time a gem's `require` runs its body and registers plugins. A second in-process
-    # `Loader.load` of the same bare-string (`id:`-less) entry sees `require` return false (the gem is already
-    # loaded, so its `Rigor::Plugin.register` calls do not re-run) and an empty newly-registered delta — the
-    # loader recovers the gem's plugin id(s) from this memo instead of failing with "did not register any
-    # plugin". Populated by {.record_gem_registration}, read by {.ids_for_gem}. This is what makes a second
-    # in-process analysis (the `--verify-incremental` full-run oracle, the incremental session's subset
-    # re-analysis, the LSP's re-loads) load the same plugins the first run did.
+    # ADR-88 WD4b — process-global map `gem name (String) => [plugin id, ...]`, recorded by the loader on a gem's
+    # first `require`. A second in-process `Loader.load` of the same bare-string entry sees `require` return false
+    # and an empty newly-registered delta; the loader then recovers the ids from this memo instead of failing with
+    # "did not register any plugin". Populated by {.record_gem_registration}, read by {.ids_for_gem}. This is what
+    # lets a second in-process analysis (the `--verify-incremental` oracle, the incremental subset re-analysis,
+    # the LSP's re-loads) load the same plugins the first run did.
     @gem_registrations = {}
     @mutex = Mutex.new
 

data/lib/rigor/plugin_gap_advisory.rb

@@ -26,7 +26,11 @@ module Rigor
       "rails" => %w[
         actioncable actionmailer actionpack actiontext actionview activejob activemodel
         activerecord activestorage activesupport railties
-      ].freeze
+      ].freeze,
+      # `rspec` and `rspec-rails` are the same shape: a project names the umbrella and never `rspec-core`, the
+      # gem rigor-rspec targets. rspec-rails depends on the three rspec gems listed here.
+      "rspec" => %w[rspec-core rspec-expectations rspec-mocks].freeze,
+      "rspec-rails" => %w[rspec-core rspec-expectations rspec-mocks].freeze
     }.freeze
 
     class << self

data/lib/rigor/project_environment.rb

@@ -72,6 +72,9 @@ module Rigor
         required_features: features,
         **dependency_discovery_options(configuration)
       )
+    rescue Environment::CoreRootError
+      # Issue #2517 — an unusable selected core is the user's to fix, never a reason to type against the default.
+      raise
     rescue StandardError
       bare(configuration, features)
     end
@@ -111,8 +114,15 @@ module Rigor
     # The dependency-discovery axes `check` reads off the configuration, as a keyword hash. Extracted so the
     # list lives in one place: every command that types against the project's real dependencies passes exactly
     # these, and adding an axis to `Environment.for_project` means adding it here once.
+    #
+    # Issue #2517 — `core_root:` rides here too although it is not discovered: it is the other half of the RBS
+    # universe `check` reads off the configuration, and every site that builds one already passes this hash.
     def dependency_discovery_options(configuration)
       {
+        core_root: configuration.core_root,
+        paths: configuration.paths,
+        exclude_patterns: configuration.exclude_patterns,
+        exclude_base: configuration.exclude_base,
         bundler_bundle_path: configuration.bundler_bundle_path,
         bundler_auto_detect: configuration.bundler_auto_detect,
         bundler_lockfile: configuration.bundler_lockfile,
@@ -166,17 +176,21 @@ module Rigor
         required_features: features,
         **dependency_discovery_options(configuration)
       )
+    rescue Environment::CoreRootError
+      raise
     rescue StandardError
       minimal(configuration, features)
     end
 
     # The last floor: RBS core plus the project's own signature paths, which cannot fail on anything outside
-    # the project itself.
+    # the project itself. The core is still the selected one (issue #2517): a floor that dropped it would type
+    # the project against APIs its Ruby does not have.
     def minimal(configuration, features = [])
       Environment.for_project(
         libraries: configuration.libraries,
         signature_paths: configuration.signature_paths,
-        required_features: features
+        required_features: features,
+        core_root: configuration.core_root
       )
     end
   end

data/lib/rigor/protection/analysis_guard.rb

@@ -8,7 +8,7 @@ module Rigor
     # nothing about the code that was analysed.
     #
     # A named class, not a bare RuntimeError: {MutationScanner#classify} already folds a per-mutant
-    # `StandardError` into the `:harness_error` bucket, and the scanner's file-level rescue must catch THIS
+    # `StandardError` into the `harness_errors` bucket, and the scanner's file-level rescue must catch THIS
     # and nothing else, so the two failure modes stay distinguishable at every site that handles either.
     #
     # Issue #790 — it says WHICH of the two refusals below fired, because they want different recovery. A

data/lib/rigor/protection/discovery_seed.rb

@@ -4,6 +4,7 @@ require_relative "../inference/parameter_inference_collector"
 require_relative "../inference/scope_indexer"
 require_relative "../inference/project_seed_tables"
 require_relative "../cache/incremental_snapshot"
+require_relative "../cache/file_digest"
 require_relative "../analysis/path_expansion"
 require_relative "../analysis/buffer_binding"
 
@@ -107,11 +108,40 @@ module Rigor
         paths = Analysis::PathExpansion.configured_files(configuration)
         return nil if paths.empty?
 
-        bundles = snapshot_bundles(configuration)
+        payload = snapshot_payload(configuration)
+        bundles = payload&.seed_bundles
         return nil if bundles.nil? || bundles.empty?
 
-        tables_for_buffer(paths: respell_for_buffer(paths, buffer), bundles: bundles, buffer: buffer,
-                          constant_sources: true)
+        spelled = respell_for_buffer(paths, buffer)
+        tables = tables_for_buffer(paths: spelled, bundles: bundles, buffer: buffer, constant_sources: true)
+        with_snapshot_param_table(tables, payload.param_table, configuration,
+                                  paths: spelled, bundles: bundles, buffer: buffer)
+      end
+
+      # Issue #2282 — under `parameter_inference: true` the snapshot also carries the call-site parameter table the
+      # writing run seeded its analysis from (`param_table`, ADR-67 WD6c), so a probe reads `@v = v` as `check`
+      # does. The table is whole-project (a callee's parameter type comes from callers in other files), so it is
+      # only as fresh as every file: it rides along ONLY when the fold re-walked nothing, that is, every path is a
+      # snapshot bundle with an unchanged digest and no path was added, removed or replaced by the editor buffer.
+      # Otherwise it is dropped, as {Analysis::IncrementalSession#fresh_param_table} recomputes rather than reuses
+      # it. Absent when the gate is off or the table is empty, which keeps the bundle-only seed.
+      def with_snapshot_param_table(tables, param_table, configuration, paths:, bundles:, buffer:)
+        return tables unless configuration.parameter_inference
+        return tables if param_table.nil? || param_table.empty?
+        return tables unless snapshot_current?(paths, bundles, buffer)
+
+        tables.merge(param_inferred_types: param_table).freeze
+      end
+
+      def snapshot_current?(paths, bundles, buffer)
+        return false unless paths.size == bundles.size
+
+        paths.all? do |path|
+          cached = bundles[path]
+          cached && cached[:digest] == Cache::FileDigest.hexdigest(buffer ? buffer.resolve(path) : path)
+        end
+      rescue SystemCallError
+        false
       end
 
       # The configured file list with the entry that reaches `buffer`'s file respelled as the buffer's logical
@@ -128,12 +158,21 @@ module Rigor
         end
       end
 
-      def snapshot_bundles(configuration)
+      # The bare single-file scope, or that scope with `seed`'s tables folded in. The one place `rigor type-of` and the
+      # language server's editor queries (#2282) fold a seed into a scope.
+      def seeded_scope(environment:, seed:)
+        base = Scope.empty(environment: environment)
+        return base if seed.nil? || seed.empty?
+
+        base.with_discovery(base.discovery.with(**seed))
+      end
+
+      def snapshot_payload(configuration)
         fingerprint = Cache::IncrementalSnapshot.fingerprint(configuration: configuration, roots: configuration.paths)
         return nil if fingerprint.nil?
 
         loaded = Cache::IncrementalSnapshot.new(root: configuration.cache_path).load_any(fingerprints: [fingerprint])
-        loaded&.last&.seed_bundles
+        loaded&.last
       end
 
       # The whole-project discovery tables, from the single-walk combined pass (one parse per file) that

data/lib/rigor/protection/mutator.rb

@@ -138,7 +138,7 @@ module Rigor
       QUOTES = ['"', "'"].freeze
       # Mutating an argument to a universal-equality method is always an equivalent mutant: Ruby's `==` / `<=>`
       # family returns false / nil on a type mismatch rather than raising, so the engine exempts them
-      # (`UNIVERSAL_EQUALITY_METHODS`). Skip them to keep survivors meaningful.
+      # (`CheckRules::UNIVERSAL_EQUALITY_METHODS`; keep the two in step). Skip them to keep survivors meaningful.
       UNIVERSAL_EQUALITY = %w[== != eql? equal? <=>].freeze
 
       # Every operator the mutator knows. Each maps to the diagnostic rule family it is *engineered* to trip when

data/lib/rigor/rbs_extended/envelope_scanner.rb

@@ -52,11 +52,9 @@ module Rigor
       #   `.rbs` files, plus the virtual entries rbs-inline and plugin `source_rbs` synthesis contribute.
       # @param registry — the vocabulary an unknown label is judged against.
       #
-      # The `ANNOTATION_HINT` routing test runs here, before any parse: a source with no honoured
-      # payload can contribute neither an envelope nor an unresolved report, so a signature tree with
-      # no effect annotation is answered by one regex per file — which is what that hint's own
-      # documentation promises, and what every warm envelope-lane run was paying a full
-      # `RBS::Parser.parse_signature` per file for.
+      # A source with no honoured payload can contribute neither an envelope nor an unresolved report, so the
+      # `ANNOTATION_HINT` test skips it before any parse: one regex per file, not a full
+      # `RBS::Parser.parse_signature`.
       def scan(sources:, registry:)
         reporter = Reporter.new
         methods = {}
@@ -128,7 +126,7 @@ module Rigor
       def walk(decl, prefix, methods, classes, registry, reporter)
         return unless decl.is_a?(::RBS::AST::Declarations::Class) || decl.is_a?(::RBS::AST::Declarations::Module)
 
-        nested = prefix + [decl.name.to_s.sub(/\A::/, "")]
+        nested = ::Rigor::Environment::RbsLoader.declared_class_path(decl, prefix)
         class_name = nested.join("::")
         envelope = RbsExtended.read_effect_envelope(
           decl.annotations, owner_key: class_name, source: :class_annotation,

data/lib/rigor/rbs_extended/hkt_directives.rb

@@ -287,17 +287,13 @@ module Rigor
         source_location.respond_to?(:start_line) ? source_location.start_line : nil
       end
 
-      # Issue #785 — routes a declined directive to the per-run reporter. The FIRST arm is the one that
-      # matters: the production reporter is {RbsExtended::Reporter}, whose surface is `record_unresolved` /
-      # `record_lossy_projection` / `record_hkt_error` — it has neither `#record` nor `#<<`, so before this
-      # arm existed every call here fell off the end of the `if` and every malformed HKT directive was
-      # dropped in every real run, while the doc comments claimed an `:info` entry was recorded. The
-      # position is flattened at record time through {RbsExtended::Reporter.position_of}, the one place
-      # every stream flattens through since #805, because the entry has to reach the pool drain channel as
-      # primitives (see {RbsExtended::Reporter}).
+      # Issue #785 — routes a declined directive to the per-run reporter. The first arm matters: the production
+      # {RbsExtended::Reporter} has `record_hkt_error` and neither `#record` nor `#<<`, so before this arm existed
+      # every malformed HKT directive was dropped in real runs. The position is flattened at record time through
+      # {RbsExtended::Reporter.position_of} (see {RbsExtended::Reporter} on why the entry carries primitives).
       #
-      # The `#record` / `#<<` arms stay for the collecting doubles the directive specs and plugin authors
-      # use, which is the contract `scan_rbs_loader`'s `@param reporter [#record, nil]` documents.
+      # The `#record` / `#<<` arms serve the collecting doubles the directive specs and plugin authors use; the
+      # contract is the one `scan_rbs_loader` documents for its `reporter` parameter.
       def record_hkt_error(reporter, message, source_location)
         return if reporter.nil?
 

data/lib/rigor/rbs_extended/reporter.rb

@@ -48,6 +48,16 @@ module Rigor
       HktDirectiveEntry = Data.define(:message, :path, :line, :column)
       DeprecatedFormEntry = Data.define(:payload, :replacement, :path, :line, :column)
 
+      # Every stream, by its reader, with the record method that replays one of its entries: an entry's
+      # members are that method's keywords. {#snapshot} and {#absorb} walk this table, so a new stream is
+      # declared here and nowhere else in the pool drain (ADR-116 WD3).
+      STREAMS = {
+        unresolved_payloads: :record_unresolved,
+        lossy_projections: :record_lossy_projection,
+        hkt_directive_errors: :record_hkt_error,
+        deprecated_forms: :record_deprecated_form
+      }.freeze
+
       # Flattens an `RBS::Location` (or anything answering the same readers) to the `(path, line, column)`
       # triple every entry carries. `column` is 1-based, since `RBS::Location#start_column` is 0-based and
       # diagnostics are not. Each component is `nil` when the location cannot supply it, and the diagnostic
@@ -160,9 +170,23 @@ module Rigor
       # True when no events have accumulated. Used by callers that want to skip the diagnostic-emission pass
       # entirely on the common no-event path.
       def empty?
-        @mutex.synchronize do
-          @unresolved_payloads.empty? && @lossy_projections.empty? && @hkt_directive_errors.empty? &&
-            @deprecated_forms.empty?
+        STREAMS.each_key.all? { |stream| public_send(stream).empty? }
+      end
+
+      # The drain a pool worker hands back: every stream's frozen entries by reader name. Marshal-clean and
+      # shareable, since each entry carries `(path, line, column)` primitives (#785, #805).
+      def snapshot
+        STREAMS.each_key.to_h { |stream| [stream, public_send(stream)] }
+      end
+
+      # Replays one worker's {#snapshot} through the record methods, whose dedup collapses the copies every
+      # worker hands over to the single row a `--workers=0` run prints. A missing stream (an older drain
+      # shape) or a nil snapshot records nothing.
+      def absorb(snapshot)
+        return if snapshot.nil?
+
+        STREAMS.each do |stream, record|
+          Array(snapshot[stream]).each { |entry| public_send(record, **entry.to_h) }
         end
       end
 

data/lib/rigor/rbs_extended.rb

@@ -513,7 +513,7 @@ module Rigor
       Type::Nominal.new(normalized)
     end
 
-    # Returned for `rigor:v1:param: <name> <refinement>`. The parameter name is a Ruby identifier (Symbol); the
+    # Returned for `rigor:v1:param: <name> <refinement>`. The parameter name is a Ruby identifier; the
     # type is any `Rigor::Type` the refinement parser resolves (bare kebab-case name, parameterised form, or
     # `Integer[a..b]` range, or the deprecated `int<a, b>` — the same grammar the `return:` directive accepts).
     ParamOverride = Data.define(:param_name, :type)
@@ -554,7 +554,7 @@ module Rigor
     end
 
     # Convenience reader for call sites that want to look up a single override by parameter name. Returns a
-    # frozen Hash<Symbol, Rigor::Type>; missing keys mean "use the RBS-declared type". Callers MUST treat the
+    # frozen map from parameter name to type; missing keys mean "use the RBS-declared type". Callers MUST treat the
     # hash as read-only.
     def param_type_override_map(method_def, environment: nil)
       overrides = read_param_type_overrides(method_def, environment: environment)
@@ -728,7 +728,6 @@ module Rigor
     NO_EFFECT_LABELS = [].freeze
     private_constant :NO_EFFECT_LABELS
 
-    # Whether `string` is the bare `%a{pure}` annotation.
     def pure_annotation?(string)
       !string.nil? && PURE_ANNOTATION_PATTERN.match?(string)
     end

data/lib/rigor/reflection/constant_ancestors.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../run_scoped_slots"
+
 module Rigor
   # {Reflection}'s constant-ancestor walk ([#354](https://github.com/rigortype/rigor/issues/354)), split out for
   # the reader rather than for the loader: the whole-spelling ladder's step 2 (`reflection.rb`) and the
@@ -8,11 +10,11 @@ module Rigor
   # keeps the walk behind the facade its callers already read.
   module Reflection
     # #354 — thread-local slot for the per-run ancestor-scope memo. See {.ancestor_constant_scopes}.
-    ANCESTOR_SCOPES_KEY = :__rigor_ancestor_constant_scopes__
+    ANCESTOR_SCOPES_KEY = RunScopedSlots.register(:__rigor_ancestor_constant_scopes__)
     private_constant :ANCESTOR_SCOPES_KEY
 
     # The recording run's slot. See {.recorded_ancestor_constant_scopes}.
-    RECORDED_ANCESTOR_SCOPES_KEY = :__rigor_recorded_ancestor_constant_scopes__
+    RECORDED_ANCESTOR_SCOPES_KEY = RunScopedSlots.register(:__rigor_recorded_ancestor_constant_scopes__)
     private_constant :RECORDED_ANCESTOR_SCOPES_KEY
 
     module_function
@@ -228,7 +230,7 @@ module Rigor
     end
     private_class_method :ancestry_unknown_before?
 
-    # Ruby places these after every entry of a chain, so a constant they own is the top level's (step 4).
+    # Ruby places these after every entry of a chain, so a constant they own is the top level's.
     IMPLICIT_ANCESTORS = %w[Object Kernel BasicObject].freeze
     private_constant :IMPLICIT_ANCESTORS
 

data/lib/rigor/rooted_glob.rb

@@ -20,7 +20,7 @@ module Rigor
 
     module_function
 
-    # @param root — a directory path (String or Pathname), taken literally
+    # @param root — a directory path, taken literally
     # @param pattern — a `Dir.glob` pattern relative to `root`
     # @return the matches spelled under `root`, in `Dir.glob` order; empty when `root` is not a directory
     def glob(root, pattern)
@@ -32,5 +32,19 @@ module Rigor
     def literal(name)
       name.to_s.gsub(METACHARACTERS, "\\\\\\0")
     end
+
+    # A configured file path (#2222), absolute or relative to the working directory, as the `[root, pattern]` pair
+    # that `glob(root, pattern)` reads as exactly that file. A relative path stays under the working directory, as
+    # it always did. An absolute one is split into its own directory and a literal basename: `File.join(".", "/abs")`
+    # reads `./abs`, so an absolute path joined under `"."` matched nothing.
+    #
+    # @param path — a file path, taken literally
+    # @return `[root, pattern]`: `"."` and the literal path when relative, else the directory and the literal basename
+    def split_file(path)
+      path = path.to_s
+      return [".", literal(path)] unless File.absolute_path?(path)
+
+      [File.dirname(path), literal(File.basename(path))]
+    end
   end
 end

data/lib/rigor/run_scoped_slots.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rigor
+  # Issues #2412 and #2399 — the registry of per-thread memo slots whose contents belong to one analysis run. An
+  # owner registers its `Thread.current` key where it names it (`KEY = RunScopedSlots.register(:key)`), and each
+  # entry point that runs an analysis calls {.release} in its `ensure`, so a finished run, or one that raised,
+  # leaves none of its scopes, discovery tables or environment behind on the thread.
+  #
+  # A slot that holds its run until the next run overwrites it retains one run per thread. A slot whose value
+  # reaches its own key retains every run, as `LoopValueRecord`'s `ObjectSpace::WeakKeyMap` did: the map holds
+  # its values strongly, and a recorded scope reaches the parse tree that holds the key node. Releasing at run end
+  # bounds both. Inside a run nothing changes: every memo keeps its key and its hit rate, and a slot read outside
+  # a run (a language-server hover on the main thread) refills on its first miss.
+  #
+  # Only memo slots belong here. A slot a `with_*` frame installs and restores around a block is already empty
+  # when the frame returns, and clearing it from inside a frame would break the frame.
+  #
+  # The registry is a module-level array filled at require time, so it is for the main Ractor only.
+  module RunScopedSlots
+    @keys = []
+
+    # Adds `key` to the registry and returns it, so the owner's constant keeps its value.
+    def self.register(key)
+      @keys << key unless @keys.include?(key)
+      key
+    end
+
+    # Every registered key, in registration order.
+    def self.keys = @keys.dup.freeze
+
+    # Empties every registered slot on the calling thread.
+    def self.release
+      thread = Thread.current
+      @keys.each { |key| thread[key] = nil }
+      nil
+    end
+  end
+end

data/lib/rigor/runtime/jit.rb

@@ -37,7 +37,7 @@ module Rigor
     # *remaining* deadline rather than restarting the window; see its own
     # comment for why that distinction is worth the bookkeeping.
     module Jit
-      # Opt-out switch: `RIGOR_DISABLE_YJIT=1` disables both entry points.
+      # Opt-out switch: `RIGOR_DISABLE_YJIT=1` disables every entry point.
       DISABLE_ENV = "RIGOR_DISABLE_YJIT"
 
       # Advanced / calibration override of the {enable_after} deadline, in

data/lib/rigor/scope/discovery_index.rb

@@ -61,6 +61,13 @@ module Rigor
     )
 
     class DiscoveryIndex
+      # Issue #2330 — identity as a hash key. `Data` hashes and compares structurally, which over these project-sized
+      # tables is both costly and wrong for a per-thread memo keyed by "this very index" (an `ObjectSpace::WeakKeyMap`
+      # holds the memo while the index lives and drops it with it). `==` stays structural.
+      def hash = object_id.hash
+
+      def eql?(other) = equal?(other)
+
       EMPTY_NODE_TABLE = {}.compare_by_identity.freeze
       EMPTY_TABLE = {}.freeze
       EMPTY_NAME_SET = Set.new.freeze
@@ -423,10 +430,9 @@ module Rigor
         struct_member_layouts: EMPTY_TABLE,
         # ADR-67 WD3 — the call-site parameter-inference table, keyed by `[class_name, method_name, kind]` (the
         # same `(class, method, kind)` triple {Inference::ParameterInferenceCollector} records and that
-        # `build_method_entry_scope` reconstructs from the lexical class path). The value is a
-        # `{param_name(Symbol) => Rigor::Type}` map of the union of resolved call-site argument types. Empty on
-        # every normal run; only the `coverage --protection` collection pass populates it today, so a `check` run
-        # leaves it empty and seeds nothing (byte-identical).
+        # `build_method_entry_scope` reconstructs from the lexical class path). The value is the
+        # union of resolved call-site argument types per parameter name. Empty unless `parameter_inference:` is
+        # on or the `coverage --protection` collection pass runs; a run with neither seeds nothing (byte-identical).
         param_inferred_types: EMPTY_TABLE,
         # ADR-84 WD2 — the run-scope identity token `Analysis::Runner#run_analysis` mints per run (a frozen
         # bare Object) and seeds through `project_scope_seed_tables`. The user-method return memo keys its
@@ -474,7 +480,6 @@ module Rigor
       # possible fact carries, and a Runner's initial state. Copy it (`dup`) before mutating.
       EMPTY_SIBLINGS = SIBLINGS.each_value.to_h { |sibling| [sibling, EMPTY.public_send(sibling)] }.freeze
 
-      # The all-empty value of a paired member or sibling.
       def self.empty_value(name)
         EMPTY.public_send(name)
       end
@@ -499,7 +504,6 @@ module Rigor
         end
       end
 
-      # Whether `name` is a member or sibling of {SIBLINGS}.
       def self.paired?(name)
         PARTNERS.key?(name)
       end
@@ -522,6 +526,15 @@ module Rigor
         recorded == kind || (!recorded.nil? && recorded == METHOD_KIND_BOTH)
       end
 
+      # Issue #681 / #707 — the `Module.nesting` the declaration walk recorded for `def_node`, or nil when it recorded
+      # none: {#discovered_def_nestings} first, then its rehydration for a def served from an ADR-85 seed bundle, whose
+      # node {Inference::DefNodeResolver} mints from its own parse ({Inference::DefNodeResolver.rehydrated_nesting}).
+      # The one reader of the table outside its owners; `ExpressionTyper#recorded_def_nesting` says why the order is
+      # safe.
+      def recorded_def_nesting(def_node)
+        discovered_def_nestings[def_node] || Inference::DefNodeResolver.rehydrated_nesting(def_node)
+      end
+
       # ADR-119 WD1 — whether `path` (`[class, name]`, or `[class, [kind, name]]` for an envelope) is a contested
       # entry of `member`, one of the single-valued members {SIBLINGS} pairs. Internal to the candidate-set read.
       def contested?(member, path)

data/lib/rigor/scope/resolution_chain.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../run_scoped_slots"
+
 module Rigor
   class Scope
     # ADR-24 (amended for #1567, #1568, #1570 and #1571) — Ruby's method resolution order for one project class or
@@ -494,7 +496,7 @@ module Rigor
       end
       private :compute_levels
 
-      MEMO_KEY = :__rigor_resolution_chain__
+      MEMO_KEY = RunScopedSlots.register(:__rigor_resolution_chain__)
       private_constant :MEMO_KEY
 
       FLAVORS = %i[methods constants arity].freeze