rigortype 0.1.3 → 0.1.5

data/lib/rigor/environment/rbs_loader.rb

@@ -49,6 +49,13 @@ module Rigor
         # miss without holding a loader instance, and the
         # instance-side {#build_env} delegates here so the
         # implementation stays single-rooted.
+        #
+        # Vendored gem stubs (`data/vendored_gem_sigs/<gem>/`) are
+        # loaded on top of `signature_paths` so the per-gem RBS
+        # bundled with Rigor itself is in scope for every analysis
+        # run. The gem stubs are intentionally read-only and
+        # appended LAST so user-supplied `signature_paths` win on
+        # name conflicts.
         def build_env_for(libraries:, signature_paths:)
           rbs_loader = RBS::EnvironmentLoader.new
           libraries.each do |library|
@@ -60,8 +67,32 @@ module Rigor
             path = Pathname(path) unless path.is_a?(Pathname)
             rbs_loader.add(path: path) if path.directory?
           end
+          vendored_gem_sig_paths.each do |path|
+            rbs_loader.add(path: path) if path.directory?
+          end
           RBS::Environment.from_loader(rbs_loader).resolve_type_names
         end
+
+        # Per-gem `data/vendored_gem_sigs/<gem>/` directories that
+        # ship with Rigor. Each subdirectory is one gem's RBS surface
+        # (the `<gem>.rbs` file is the typical content; `LICENSE.upstream`
+        # records provenance). Coverage is deliberately scoped to the
+        # native-extension and "everywhere in Rails" gems whose absence
+        # dominated `call.undefined-method` noise in the real-world
+        # survey at `docs/notes/20260515-real-world-rails-survey.md`.
+        VENDORED_GEM_SIGS_ROOT = File.expand_path(
+          "../../../data/vendored_gem_sigs",
+          __dir__
+        )
+        private_constant :VENDORED_GEM_SIGS_ROOT
+
+        def vendored_gem_sig_paths
+          return [] unless File.directory?(VENDORED_GEM_SIGS_ROOT)
+
+          Dir.children(VENDORED_GEM_SIGS_ROOT).map do |gem_dir|
+            Pathname(File.join(VENDORED_GEM_SIGS_ROOT, gem_dir))
+          end
+        end
       end
 
       attr_reader :libraries, :signature_paths, :cache_store
@@ -122,6 +153,7 @@ module Rigor
       # it never recurses back through {#class_known?}.
       def each_known_class_name
         return enum_for(:each_known_class_name) unless block_given?
+        return if env.nil?
 
         env.class_decls.each_key { |rbs_name| yield rbs_name.to_s }
         env.class_alias_decls.each_key { |rbs_name| yield rbs_name.to_s }
@@ -133,6 +165,38 @@ module Rigor
         # v0.0.9 cache `Cache::Descriptor` regression did.
       end
 
+      # Returns a frozen `Hash<String, String>` mapping each loaded
+      # class / module name (top-level prefixed) to the file path of
+      # its FIRST declaration's RBS source. Used by
+      # {Rigor::Analysis::RunStats} to attribute the type universe
+      # between "project sig/" (paths under the configured
+      # `signature_paths`) and "bundled" (everything else — RBS
+      # core, stdlib libraries, gem-bundled RBS). Each value is a
+      # frozen `String` so the whole result is `Ractor.shareable?`
+      # — the Phase 4b worker pool ships a snapshot back to the
+      # coordinator on the first `:prepare` message.
+      def class_decl_paths
+        return {}.freeze if env.nil?
+
+        result = {}
+        env.class_decls.each do |rbs_name, entry|
+          decl = entry.primary_decl
+          next if decl.nil?
+
+          location = decl.location
+          next if location.nil?
+
+          buffer = location.buffer
+          name = buffer.respond_to?(:name) ? buffer.name : nil
+          next if name.nil?
+
+          result[rbs_name.to_s.dup.freeze] = name.to_s.dup.freeze
+        end
+        result.freeze
+      rescue ::RBS::BaseError
+        {}.freeze
+      end
+
       # @return [RBS::Definition, nil] the resolved instance definition
       #   for `class_name`, or nil when the class is unknown or its
       #   definition cannot be built (RBS may raise on broken hierarchies;
@@ -250,6 +314,8 @@ module Rigor
       #   materialises the constant-type table; ordinary callers
       #   should keep using {#constant_type} for point lookups.
       def constant_names
+        return [] if env.nil?
+
         env.constant_decls.keys.map(&:to_s)
       rescue ::RBS::BaseError
         []
@@ -262,6 +328,7 @@ module Rigor
       # back into the cache when `cache_store` is set).
       def each_constant_decl
         return enum_for(:each_constant_decl) unless block_given?
+        return if env.nil?
 
         env.constant_decls.each do |rbs_name, entry|
           yield rbs_name.to_s, entry
@@ -299,26 +366,109 @@ module Rigor
         nil
       end
 
+      # ADR-15 Phase 4b.x — eagerly drives every cached
+      # producer so a subsequent worker Ractor can serve all
+      # of its RBS queries from the Marshal blob on disk
+      # without ever calling `RBS::EnvironmentLoader.new`.
+      # The loader path that calls `EnvironmentLoader.new`
+      # transitively reads a chain of non-`Ractor.shareable?`
+      # module constants
+      # (`RBS::EnvironmentLoader::DEFAULT_CORE_ROOT`,
+      # `RBS::Repository::DEFAULT_STDLIB_ROOT`,
+      # `Gem::Requirement::DefaultRequirement`, …) and trips
+      # `Ractor::IsolationError`. Pre-warming the cache on
+      # the main Ractor and letting workers consult ONLY the
+      # Marshal-loaded blob sidesteps the whole chain.
+      #
+      # No-op when `cache_store` is nil — without a Store the
+      # worker has no choice but to build env via the loader,
+      # so the caller MUST ensure pool mode runs with caching
+      # enabled. Returns `self` so the call chains cleanly
+      # from the `Runner` pre-spawn hook.
+      def prewarm
+        return self if cache_store.nil?
+
+        env
+        known_class_names_set
+        constant_type_table
+        type_param_names_table
+        ancestor_names_table
+        instance_definitions_table
+        singleton_definitions_table
+        self
+      end
+
+      # ADR-15 Phase 2b — return the loader's read-only
+      # query surface as a frozen, `Ractor.shareable?`
+      # {Reflection} value object. Built lazily on first
+      # access; the loader memoises so repeated calls return
+      # the same instance.
+      #
+      # The Reflection consumes the loader's already-warmed
+      # cache producers (or, when no `cache_store` is set,
+      # eagerly walks the env). Once constructed, the
+      # Reflection carries the derived tables independently
+      # and never re-consults the loader — making it safe to
+      # share across Ractors while the loader stays per-
+      # process / per-Ractor for write-path operations.
+      def reflection
+        @state[:reflection] ||= begin
+          require_relative "reflection"
+          Environment::Reflection.new(
+            known_class_names: known_class_names_set,
+            instance_definitions: instance_definitions_table,
+            singleton_definitions: singleton_definitions_table,
+            type_param_names: type_param_names_table,
+            constant_types: constant_type_table,
+            ancestor_names: ancestor_names_table
+          )
+        end
+      end
+
       private
 
       def constant_type_table
         @constant_type_table ||= begin
           require_relative "../cache/rbs_constant_table"
-          Cache::RbsConstantTable.fetch(loader: self, store: cache_store)
+          fetch_or_compute_producer(Cache::RbsConstantTable)
         end
       end
 
       def known_class_names_set
         @known_class_names_set ||= begin
           require_relative "../cache/rbs_known_class_names"
-          Cache::RbsKnownClassNames.fetch(loader: self, store: cache_store)
+          fetch_or_compute_producer(Cache::RbsKnownClassNames)
         end
       end
 
       def type_param_names_table
         @type_param_names_table ||= begin
           require_relative "../cache/rbs_class_type_param_names"
-          Cache::RbsClassTypeParamNames.fetch(loader: self, store: cache_store)
+          fetch_or_compute_producer(Cache::RbsClassTypeParamNames)
+        end
+      end
+
+      # ADR-15 Phase 2b — the `Reflection` build path
+      # consumes these tables even when `cache_store` is nil
+      # (e.g. tests that build a `Reflection` without a
+      # persistent cache). The helper routes through the
+      # producer's `.fetch` when a store IS available, and
+      # falls back to the producer's `.compute` otherwise.
+      def fetch_or_compute_producer(producer)
+        return producer.fetch(loader: self, store: cache_store) if cache_store
+
+        producer.send(:compute, self)
+      end
+
+      # ADR-15 Phase 2b — `Hash<String, Array<String>>` of
+      # normalised ancestor chains per class. Consumes the
+      # existing `RbsClassAncestorTable` producer when
+      # `cache_store` is set; falls back to the producer's
+      # `compute` otherwise. Used by {#reflection}.
+      def ancestor_names_table
+        @ancestor_names_table ||= begin
+          require_relative "../cache/rbs_class_ancestor_table"
+          fetch_or_compute_producer(Cache::RbsClassAncestorTable)
         end
       end
 
@@ -332,6 +482,8 @@ module Rigor
       end
 
       def translate_constant_decl(rbs_name)
+        return nil if env.nil?
+
         entry = env.constant_decls[rbs_name]
         return nil unless entry
 
@@ -339,8 +491,41 @@ module Rigor
         translated unless translated.is_a?(Type::Bot)
       end
 
+      # The RBS environment for this loader. Memoised both on
+      # success AND on failure: when the env build raises
+      # (typically `RBS::DuplicatedDeclarationError` because a
+      # `signature_paths:` entry redeclares a constant or class
+      # already shipped by stdlib RBS), retrying on every
+      # subsequent `env` call would re-parse and re-resolve the
+      # whole sig set per AST node touched during analysis,
+      # multiplying per-file analysis cost by ~100x. Failures
+      # short-circuit to `nil` here and are surfaced to the user
+      # via `warn_about_env_build_failure_once` so the broken
+      # `signature_paths:` entry is identifiable.
       def env
-        @state[:env] ||= cache_store ? cached_env : build_env
+        return @state[:env] if @state[:env_loaded]
+
+        @state[:env_loaded] = true
+        @state[:env] = cache_store ? cached_env : build_env
+      rescue ::RBS::BaseError => e
+        warn_about_env_build_failure_once(e)
+        @state[:env] = nil
+      end
+
+      def warn_about_env_build_failure_once(error)
+        return if @state[:env_build_warned]
+
+        @state[:env_build_warned] = true
+        first_line = error.message.to_s.lines.first.to_s.strip
+        warn(
+          "rigor: RBS environment build failed: #{error.class}: #{first_line}\n  " \
+          "Likely cause: a `signature_paths:` entry redeclares a constant or class\n  " \
+          "already shipped by Rigor's bundled RBS (Ruby core / stdlib / gem-bundled\n  " \
+          "RBS / `data/vendored_gem_sigs/`). Rigor will continue analyzing with no\n  " \
+          "RBS env in scope, so most type-of queries will return `Dynamic[top]` and\n  " \
+          "most rule diagnostics will not fire. Remove the conflicting `.rbs` from\n  " \
+          "your `signature_paths:` to restore type coverage."
+        )
       end
 
       def cached_env
@@ -362,7 +547,7 @@ module Rigor
       def instance_definitions_table
         @state[:instance_definitions_table] ||= begin
           require_relative "../cache/rbs_instance_definitions"
-          Cache::RbsInstanceDefinitions.fetch(loader: self, store: cache_store)
+          fetch_or_compute_producer(Cache::RbsInstanceDefinitions)
         end
       end
 
@@ -373,7 +558,7 @@ module Rigor
       def singleton_definitions_table
         @state[:singleton_definitions_table] ||= begin
           require_relative "../cache/rbs_instance_definitions"
-          Cache::RbsSingletonDefinitions.fetch(loader: self, store: cache_store)
+          fetch_or_compute_producer(Cache::RbsSingletonDefinitions)
         end
       end
 
@@ -398,6 +583,7 @@ module Rigor
       def build_instance_definition(class_name)
         rbs_name = parse_type_name(class_name)
         return nil unless rbs_name
+        return nil if env.nil?
         return nil unless env.class_decls.key?(rbs_name)
 
         builder.build_instance(rbs_name)
@@ -408,6 +594,7 @@ module Rigor
       def build_singleton_definition(class_name)
         rbs_name = parse_type_name(class_name)
         return nil unless rbs_name
+        return nil if env.nil?
         return nil unless env.class_decls.key?(rbs_name)
 
         builder.build_singleton(rbs_name)
@@ -428,6 +615,7 @@ module Rigor
       def compute_class_known(name)
         rbs_name = parse_type_name(name)
         return false unless rbs_name
+        return false if env.nil?
 
         # `RBS::Environment#class_decls` after `resolve_type_names`
         # holds entries for both classes AND modules; the gem unifies

data/lib/rigor/environment/reflection.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Environment
+    # Frozen, `Ractor.shareable?` read-only RBS query facade.
+    # [ADR-15](../../../docs/adr/15-ractor-concurrency.md)
+    # Phase 2b extracts the read-only surface of {RbsLoader}
+    # into this carrier so future Ractor-isolated workers
+    # can share one Reflection across the pool while keeping
+    # the per-Ractor mutable accelerator state (per-process
+    # memo Hashes) where it belongs.
+    #
+    # Backing tables (all frozen at construction):
+    #
+    # - `known_class_names` — `Set<String>` of every
+    #   class / module / alias name in the loaded RBS
+    #   environment. Top-level prefixed (`"::Hash"`); plain
+    #   queries normalise via {#normalise}.
+    # - `instance_definitions` —
+    #   `Hash<String, RBS::Definition>` keyed on
+    #   `RBS::TypeName#to_s` (top-level prefixed).
+    # - `singleton_definitions` — same shape, singleton side.
+    # - `type_param_names` —
+    #   `Hash<String, Array<Symbol>>` of declared type
+    #   parameters per class.
+    # - `constant_types` — `Hash<String, Rigor::Type>` of
+    #   translated constant declarations.
+    # - `ancestor_names` — `Hash<String, Array<String>>` of
+    #   normalised ancestor chains per class.
+    #
+    # Each `Reflection` instance is `frozen?` at construction
+    # — every cached table is frozen, `self` is frozen.
+    # **NOT** `Ractor.shareable?`: the `instance_definitions`
+    # / `singleton_definitions` tables hold upstream
+    # `RBS::Definition` objects that transitively reference
+    # `RBS::Location` (C-extension state that
+    # `Ractor.make_shareable` rejects).
+    #
+    # The Ractor worker pool (ADR-15 Phase 4) sidesteps this
+    # by having each worker build ITS OWN `Reflection` from
+    # the shared `Cache::Store`. The cross-Ractor sharing
+    # point is the Store's on-disk + in-process memo layer,
+    # NOT the Reflection itself. Each Reflection is a per-
+    # Ractor immutable read-side view; this carrier exists
+    # to GUARANTEE the per-worker view never mutates after
+    # construction.
+    #
+    # If a future RBS release makes `RBS::Location`
+    # Ractor-shareable, swapping the `freeze` call below for
+    # `Ractor.make_shareable(self)` makes the whole carrier
+    # cross-Ractor-shareable in one line. Until then, the
+    # frozen-read-only contract is the deliverable.
+    class Reflection
+      attr_reader :known_class_names, :instance_definitions, :singleton_definitions,
+                  :type_param_names, :constant_types, :ancestor_names
+
+      def initialize(known_class_names:, instance_definitions:, singleton_definitions:,
+                     type_param_names:, constant_types:, ancestor_names:)
+        @known_class_names = freeze_set(known_class_names)
+        @instance_definitions = freeze_hash(instance_definitions)
+        @singleton_definitions = freeze_hash(singleton_definitions)
+        @type_param_names = freeze_hash(type_param_names)
+        @constant_types = freeze_hash(constant_types)
+        @ancestor_names = freeze_hash(ancestor_names)
+        freeze
+      end
+
+      def class_known?(name)
+        @known_class_names.include?(rooted(name))
+      end
+
+      def instance_definition(name)
+        @instance_definitions[rooted(name)]
+      end
+
+      def singleton_definition(name)
+        @singleton_definitions[rooted(name)]
+      end
+
+      def class_type_param_names(name)
+        @type_param_names.fetch(unrooted(name), [])
+      end
+
+      def constant_type(name)
+        @constant_types[rooted(name)]
+      end
+
+      # Three-valued `(lhs, rhs)` relation:
+      # `:equal` / `:subclass` / `:superclass` / `:disjoint` /
+      # `:unknown`. Mirrors {RbsHierarchy#class_ordering}'s
+      # contract; the Reflection's frozen ancestor table
+      # supports the same queries without any in-process
+      # mutation.
+      def class_ordering(lhs, rhs)
+        lhs = unrooted(lhs)
+        rhs = unrooted(rhs)
+        return :equal if lhs == rhs
+
+        lhs_ancestors = @ancestor_names[lhs]
+        rhs_ancestors = @ancestor_names[rhs]
+        return :unknown if lhs_ancestors.nil? || rhs_ancestors.nil? || lhs_ancestors.empty? || rhs_ancestors.empty?
+
+        if lhs_ancestors.include?(rhs)
+          :subclass
+        elsif rhs_ancestors.include?(lhs)
+          :superclass
+        else
+          :disjoint
+        end
+      end
+
+      # Yields every known class / module / alias name in
+      # the loader's canonical rooted form (`"::Hash"`).
+      def each_known_class_name(&)
+        @known_class_names.each(&)
+      end
+
+      private
+
+      # The cached tables use mixed key conventions inherited
+      # from the underlying RBS::TypeName surface: the
+      # name-set / definition tables / constant table store
+      # rooted `"::Foo"` keys; the type-param / ancestor
+      # tables store unrooted `"Foo"`. Reflection's queries
+      # normalise per-lookup so callers can pass either form.
+      def rooted(name)
+        s = name.to_s
+        s.start_with?("::") ? s : "::#{s}"
+      end
+
+      def unrooted(name)
+        name.to_s.delete_prefix("::")
+      end
+
+      def freeze_set(value)
+        return value if value.is_a?(Set) && value.frozen?
+
+        case value
+        when Set then value.dup.freeze
+        when Array, Hash then Set.new(value).freeze
+        else raise ArgumentError, "expected Set / Array / Hash, got #{value.class}"
+        end
+      end
+
+      def freeze_hash(value)
+        return value if value.frozen?
+
+        value.dup.freeze
+      end
+    end
+  end
+end

data/lib/rigor/environment.rb

@@ -2,6 +2,14 @@
 
 require_relative "environment/class_registry"
 require_relative "environment/rbs_loader"
+require_relative "environment/reflection"
+require_relative "environment/bundle_sig_discovery"
+require_relative "environment/lockfile_resolver"
+require_relative "environment/rbs_collection_discovery"
+require_relative "environment/rbs_coverage_report"
+require_relative "inference/synthetic_method_index"
+require_relative "type_node/name_scope"
+require_relative "type_node/resolver_chain"
 
 module Rigor
   # The engine's view of the type universe outside the current scope.
@@ -38,10 +46,19 @@ module Rigor
       pathname optparse json yaml fileutils tempfile tmpdir
       stringio forwardable digest securerandom
       uri logger date
+      pp delegate observable abbrev find tsort singleton
+      shellwords benchmark base64 did_you_mean
+      monitor mutex_m timeout
+      open3 erb etc ipaddr bigdecimal bigdecimal-math
+      prettyprint random-formatter time open-uri resolv
+      csv pstore objspace io-console cgi cgi-escape
+      strscan
       prism rbs
     ].freeze
 
-    attr_reader :class_registry, :rbs_loader, :plugin_registry, :dependency_source_index
+    attr_reader :class_registry, :rbs_loader, :plugin_registry, :dependency_source_index,
+                :rbs_extended_reporter, :boundary_cross_reporter, :name_scope,
+                :synthetic_method_index
 
     # @param class_registry [Rigor::Environment::ClassRegistry]
     # @param rbs_loader [Rigor::Environment::RbsLoader, nil] when nil the
@@ -63,11 +80,17 @@ module Rigor
     #   When nil (the default), no dep-source contribution
     #   participates and the dispatcher tier is a no-op.
     def initialize(class_registry: ClassRegistry.default, rbs_loader: nil,
-                   plugin_registry: nil, dependency_source_index: nil)
+                   plugin_registry: nil, dependency_source_index: nil,
+                   rbs_extended_reporter: nil, boundary_cross_reporter: nil,
+                   synthetic_method_index: nil)
       @class_registry = class_registry
       @rbs_loader = rbs_loader
       @plugin_registry = plugin_registry
       @dependency_source_index = dependency_source_index
+      @rbs_extended_reporter = rbs_extended_reporter
+      @boundary_cross_reporter = boundary_cross_reporter
+      @synthetic_method_index = synthetic_method_index || Inference::SyntheticMethodIndex::EMPTY
+      @name_scope = build_name_scope
       freeze
     end
 
@@ -97,21 +120,69 @@ module Rigor
       #   reflection artefacts) consult the cache. Pass `nil` (the
       #   default) to skip caching for this environment.
       # @return [Rigor::Environment]
-      def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil, # rubocop:disable Metrics/ParameterLists
-                      plugin_registry: nil, dependency_source_index: nil)
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil,
+                      plugin_registry: nil, dependency_source_index: nil,
+                      rbs_extended_reporter: nil, boundary_cross_reporter: nil,
+                      bundler_bundle_path: nil, bundler_auto_detect: false,
+                      bundler_lockfile: nil,
+                      rbs_collection_lockfile: nil, rbs_collection_auto_detect: false,
+                      synthetic_method_index: nil)
         resolved_paths = signature_paths || default_signature_paths(root)
+        # O4 MVP — append per-gem `sig/` directories discovered
+        # under the target project's bundler install root. Empty
+        # array when neither an explicit path nor auto-detection
+        # finds a bundle. Order: user `signature_paths:` win first
+        # (semantic precedence inside `RbsLoader.build_env_for`);
+        # gem-shipped sigs append last so user overrides stay
+        # authoritative.
+        #
+        # O4 Layer 3 — when a Gemfile.lock is available (explicit
+        # `bundler_lockfile:` or auto-detected next to the project
+        # root), use the locked gem set to filter the discovered
+        # `sig/` directories. Stale gems in the bundle install
+        # tree (out-of-band installs, version drift after a
+        # `bundle update`) are silently dropped so only gems the
+        # project actually declares contribute RBS.
+        locked = LockfileResolver.locked_gems(
+          lockfile_path: bundler_lockfile,
+          project_root: root,
+          auto_detect: bundler_auto_detect
+        )
+        gem_sig_paths = BundleSigDiscovery.discover(
+          bundle_path: bundler_bundle_path,
+          project_root: root,
+          auto_detect: bundler_auto_detect,
+          locked_gems: locked.empty? ? nil : locked
+        ).map(&:to_s)
+        # O4 Layer 3 slice 2 — when `rbs collection install`
+        # has been run for the target project, parse the
+        # resulting `rbs_collection.lock.yaml` and feed each
+        # gem's `<collection_path>/<name>/<version>/` directory
+        # into `signature_paths:`. Stdlib-typed entries are
+        # skipped (already covered by `DEFAULT_LIBRARIES`).
+        collection_paths = RbsCollectionDiscovery.discover(
+          lockfile_path: rbs_collection_lockfile,
+          project_root: root,
+          auto_detect: rbs_collection_auto_detect
+        ).map(&:to_s)
+        loader_signature_paths = resolved_paths + gem_sig_paths + collection_paths
         merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
         loader = RbsLoader.new(
           libraries: merged_libraries,
-          signature_paths: resolved_paths,
+          signature_paths: loader_signature_paths,
           cache_store: cache_store
         )
         new(
           rbs_loader: loader,
           plugin_registry: plugin_registry,
-          dependency_source_index: dependency_source_index
+          dependency_source_index: dependency_source_index,
+          rbs_extended_reporter: rbs_extended_reporter,
+          boundary_cross_reporter: boundary_cross_reporter,
+          synthetic_method_index: synthetic_method_index
         )
       end
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
 
       private
 
@@ -175,6 +246,17 @@ module Rigor
       class_known_in_rbs?(name)
     end
 
+    # ADR-15 Phase 2b — returns the loader's read-only,
+    # `Ractor.shareable?` query surface as a frozen
+    # {Environment::Reflection}. Built lazily on first
+    # access; subsequent calls return the same instance.
+    # Returns `nil` when the environment carries no RBS
+    # loader (test-only `Environment.new` without
+    # `rbs_loader:`).
+    def reflection
+      @rbs_loader&.reflection
+    end
+
     # Compares two class/module names using analyzer-owned class data.
     # Returns `:equal`, `:subclass`, `:superclass`, `:disjoint`, or
     # `:unknown`. The static registry handles built-ins cheaply; the RBS
@@ -204,5 +286,26 @@ module Rigor
     def normalize_class_name(name)
       name.to_s.delete_prefix("::")
     end
+
+    # ADR-13 slice 3b — composes the per-run plugin-supplied
+    # {Rigor::TypeNode::ResolverChain} into a single
+    # {Rigor::TypeNode::NameScope} that the RBS::Extended
+    # directive parser threads down to the
+    # {Rigor::Builtins::ImportedRefinements::Resolver}. Returns
+    # `nil` when no plugin contributes a type-node resolver so
+    # the parser short-circuits the chain consultation and
+    # behaves bit-for-bit like the v0.1.0 → v0.1.3 default.
+    def build_name_scope
+      return nil if @plugin_registry.nil? || @plugin_registry.empty?
+
+      resolvers = @plugin_registry.type_node_resolvers
+      return nil if resolvers.empty?
+
+      TypeNode::NameScope.new(
+        resolver: TypeNode::ResolverChain.new(resolvers),
+        class_context: nil,
+        type_alias_table: {}
+      )
+    end
   end
 end

data/lib/rigor/flow_contribution/conflict.rb

@@ -28,8 +28,8 @@ module Rigor
       lower_tier_contradiction
     ].freeze
 
-    Conflict = Data.define(:target, :edge, :kind, :reason, :provenances, :message) do
-      def initialize(target:, edge:, kind:, reason:, provenances:, message:) # rubocop:disable Metrics/ParameterLists
+    class Conflict < Data.define(:target, :edge, :kind, :reason, :provenances, :message)
+      def initialize(target:, edge:, kind:, reason:, provenances:, message:)
         unless CONFLICT_VALID_REASONS.include?(reason)
           raise ArgumentError,
                 "FlowContribution::Conflict reason must be one of " \

data/lib/rigor/flow_contribution/element.rb

@@ -28,7 +28,7 @@ module Rigor
       role
     ].freeze
 
-    Element = Data.define(:target, :edge, :kind, :payload, :provenance) do
+    class Element < Data.define(:target, :edge, :kind, :payload, :provenance)
       def initialize(target:, edge:, kind:, payload:, provenance:)
         unless ELEMENT_VALID_EDGES.include?(edge)
           raise ArgumentError,

data/lib/rigor/flow_contribution/fact.rb

@@ -55,7 +55,7 @@ module Rigor
     # land in the same merge bucket.
     FACT_VALID_TARGET_KINDS = %i[parameter self].freeze
 
-    Fact = Data.define(:target_kind, :target_name, :type, :negative) do
+    class Fact < Data.define(:target_kind, :target_name, :type, :negative)
       def initialize(target_kind:, target_name:, type:, negative: false)
         unless FACT_VALID_TARGET_KINDS.include?(target_kind)
           raise ArgumentError,

data/lib/rigor/flow_contribution/merge_result.rb

@@ -42,7 +42,7 @@ module Rigor
         !@conflicts.empty?
       end
 
-      def empty? # rubocop:disable Metrics/CyclomaticComplexity
+      def empty?
         @return_type.nil? && @truthy_facts.empty? && @falsey_facts.empty? &&
           @post_return_facts.empty? && @mutations.empty? && @invalidations.empty? &&
           @exceptional.nil? && @role_conformance.empty?