rigortype 0.1.16 → 0.1.18

data/lib/rigor/rbs_extended.rb

@@ -608,6 +608,45 @@ module Rigor
       ParamOverride.new(param_name: match[:param].to_sym, type: type)
     end
 
+    # A class- / module-level directive declaring that the
+    # annotated class satisfies a named structural interface as
+    # part of its public contract (spec:
+    # `docs/type-specification/rbs-extended.md` § "Explicit
+    # conformance directive"). Unlike the per-method directives
+    # above, this attaches to a `class` / `module` declaration and
+    # names a single RBS interface (`_RewindableStream`); the
+    # right-hand side is therefore an interface name (its last
+    # segment begins with `_`), never a refinement payload.
+    #
+    # This parser only extracts the interface name; the
+    # conformance check itself lives in
+    # {Rigor::RbsExtended::ConformanceChecker}, which the
+    # {Rigor::Analysis::Runner} runs once per project run.
+    CONFORMS_TO_DIRECTIVE_PATTERN = /
+      \A
+      rigor:v1:conforms-to
+      \s+
+      (?<interface>(?:::)?(?:[A-Z]\w*::)*_[A-Za-z]\w*)
+      \s*
+      \z
+    /x
+    private_constant :CONFORMS_TO_DIRECTIVE_PATTERN
+
+    # Returns the interface name (leading `::` stripped) for a
+    # `rigor:v1:conforms-to <Interface>` annotation, or `nil` when
+    # the string is not a conforms-to directive (so callers can
+    # walk an annotation list without pre-filtering). The name is
+    # returned verbatim otherwise — namespace resolution happens at
+    # the loader boundary when the interface is built.
+    def parse_conforms_to_annotation(string)
+      return nil if string.nil?
+
+      match = CONFORMS_TO_DIRECTIVE_PATTERN.match(string)
+      return nil if match.nil?
+
+      match[:interface].to_s.sub(/\A::/, "")
+    end
+
     # The shared {Rigor::FlowContribution::Provenance} for every
     # bundle this module produces. `source_family: :rbs_extended`
     # so consumers (today the documentation surface; v0.1.0 the

data/lib/rigor/scope/discovery_index.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Scope
+    # ADR-53 Track A — the seed-time discovery context every Scope snapshot
+    # carries by a single reference. Holds the tables the index-time
+    # pre-passes (`Inference::ScopeIndexer` per file, plus the cross-file
+    # project pre-pass) populate and that no control-flow transition ever
+    # varies: `Scope#==` ignores them and `Scope#join` copies them from the
+    # receiver unexamined, which is the membership litmus the ADR fixes.
+    #
+    # Immutable (`Data` instances are frozen); deriving a seeded index goes
+    # through `#with(table_name: table)`. `Scope` exposes each table through
+    # its existing reader surface, so engine call sites and plugins are
+    # unaffected by the extraction.
+    DiscoveryIndex = Data.define(
+      :declared_types,
+      :class_ivars,
+      :class_cvars,
+      :program_globals,
+      :discovered_classes,
+      :in_source_constants,
+      :discovered_methods,
+      :discovered_def_nodes,
+      :discovered_def_sources,
+      :discovered_method_visibilities,
+      :discovered_superclasses,
+      :discovered_includes,
+      :discovered_class_sources,
+      :data_member_layouts
+    )
+
+    class DiscoveryIndex
+      EMPTY_NODE_TABLE = {}.compare_by_identity.freeze
+      EMPTY_TABLE = {}.freeze
+      private_constant :EMPTY_NODE_TABLE, :EMPTY_TABLE
+
+      # The shared all-empty index `Scope.empty` (and every scope that never
+      # sees a seeding pass) points at — one allocation per process.
+      EMPTY = new(
+        declared_types: EMPTY_NODE_TABLE,
+        class_ivars: EMPTY_TABLE,
+        class_cvars: EMPTY_TABLE,
+        program_globals: EMPTY_TABLE,
+        discovered_classes: EMPTY_TABLE,
+        in_source_constants: EMPTY_TABLE,
+        discovered_methods: EMPTY_TABLE,
+        discovered_def_nodes: EMPTY_TABLE,
+        discovered_def_sources: EMPTY_TABLE,
+        discovered_method_visibilities: EMPTY_TABLE,
+        discovered_superclasses: EMPTY_TABLE,
+        discovered_includes: EMPTY_TABLE,
+        discovered_class_sources: EMPTY_TABLE,
+        data_member_layouts: EMPTY_TABLE
+      )
+    end
+  end
+end

data/lib/rigor/scope.rb

@@ -2,8 +2,11 @@
 
 require_relative "type"
 require_relative "environment"
+require_relative "scope/discovery_index"
 require_relative "analysis/fact_store"
+require_relative "analysis/dependency_recorder"
 require_relative "inference/expression_typer"
+require_relative "inference/flow_tracer"
 require_relative "inference/statement_evaluator"
 
 module Rigor
@@ -16,14 +19,36 @@ module Rigor
   # See docs/internal-spec/inference-engine.md for the binding contract.
   # rubocop:disable Metrics/ClassLength,Metrics/ParameterLists
   class Scope
-    attr_reader :environment, :locals, :fact_store, :self_type, :declared_types,
+    attr_reader :environment, :locals, :fact_store, :self_type,
                 :ivars, :cvars, :globals,
-                :class_ivars, :class_cvars, :program_globals,
-                :discovered_classes, :in_source_constants, :discovered_methods,
-                :discovered_def_nodes, :discovered_def_sources, :discovered_method_visibilities,
-                :discovered_superclasses, :discovered_includes,
                 :indexed_narrowings, :method_chain_narrowings,
-                :source_path
+                :source_path, :discovery
+
+    # ADR-53 Track A — the seed-time discovery tables live on the
+    # {DiscoveryIndex} the scope carries by a single reference; the
+    # per-table readers stay on Scope so engine call sites and plugins
+    # are unaffected by the extraction. The whole index is swapped in
+    # one transition through {#with_discovery}.
+    #
+    # `declared_types` carries the identity-comparing
+    # `Prism::Node => Rigor::Type` declaration overrides
+    # `ExpressionTyper#type_of(node)` MUST consult before any other
+    # dispatch (a `module Foo` / `class Bar` header types as
+    # `Singleton[<qualified path>]` rather than `Dynamic[Top]`).
+    def declared_types = @discovery.declared_types
+    def class_ivars = @discovery.class_ivars
+    def class_cvars = @discovery.class_cvars
+    def program_globals = @discovery.program_globals
+    def discovered_classes = @discovery.discovered_classes
+    def in_source_constants = @discovery.in_source_constants
+    def discovered_methods = @discovery.discovered_methods
+    def discovered_def_nodes = @discovery.discovered_def_nodes
+    def discovered_def_sources = @discovery.discovered_def_sources
+    def discovered_method_visibilities = @discovery.discovered_method_visibilities
+    def discovered_superclasses = @discovery.discovered_superclasses
+    def discovered_includes = @discovery.discovered_includes
+    def discovered_class_sources = @discovery.discovered_class_sources
+    def data_member_layouts = @discovery.data_member_layouts
 
     # Narrowing key for an indexed read `receiver[key]` where both
     # the receiver and the key are stable enough to address. The
@@ -58,13 +83,10 @@ module Rigor
     # multi-hop loses the LoD guarantee).
     ChainKey = Data.define(:receiver_kind, :receiver_name, :method_name)
 
-    EMPTY_DECLARED_TYPES = {}.compare_by_identity.freeze
     EMPTY_VAR_BINDINGS = {}.freeze
-    EMPTY_CLASS_BINDINGS = {}.freeze
     EMPTY_INDEXED_NARROWINGS = {}.freeze
     EMPTY_CHAIN_NARROWINGS = {}.freeze
-    private_constant :EMPTY_DECLARED_TYPES, :EMPTY_VAR_BINDINGS,
-                     :EMPTY_CLASS_BINDINGS, :EMPTY_INDEXED_NARROWINGS,
+    private_constant :EMPTY_VAR_BINDINGS, :EMPTY_INDEXED_NARROWINGS,
                      :EMPTY_CHAIN_NARROWINGS
 
     class << self
@@ -78,21 +100,10 @@ module Rigor
       environment:, locals:,
       fact_store: Analysis::FactStore.empty,
       self_type: nil,
-      declared_types: EMPTY_DECLARED_TYPES,
       ivars: EMPTY_VAR_BINDINGS,
       cvars: EMPTY_VAR_BINDINGS,
       globals: EMPTY_VAR_BINDINGS,
-      class_ivars: EMPTY_CLASS_BINDINGS,
-      class_cvars: EMPTY_CLASS_BINDINGS,
-      program_globals: EMPTY_VAR_BINDINGS,
-      discovered_classes: EMPTY_VAR_BINDINGS,
-      in_source_constants: EMPTY_VAR_BINDINGS,
-      discovered_methods: EMPTY_CLASS_BINDINGS,
-      discovered_def_nodes: EMPTY_CLASS_BINDINGS,
-      discovered_def_sources: EMPTY_CLASS_BINDINGS,
-      discovered_method_visibilities: EMPTY_CLASS_BINDINGS,
-      discovered_superclasses: EMPTY_CLASS_BINDINGS,
-      discovered_includes: EMPTY_CLASS_BINDINGS,
+      discovery: DiscoveryIndex::EMPTY,
       indexed_narrowings: EMPTY_INDEXED_NARROWINGS,
       method_chain_narrowings: EMPTY_CHAIN_NARROWINGS,
       source_path: nil
@@ -101,21 +112,10 @@ module Rigor
       @locals = locals
       @fact_store = fact_store
       @self_type = self_type
-      @declared_types = declared_types
       @ivars = ivars
       @cvars = cvars
       @globals = globals
-      @class_ivars = class_ivars
-      @class_cvars = class_cvars
-      @program_globals = program_globals
-      @discovered_classes = discovered_classes
-      @in_source_constants = in_source_constants
-      @discovered_methods = discovered_methods
-      @discovered_def_nodes = discovered_def_nodes
-      @discovered_def_sources = discovered_def_sources
-      @discovered_method_visibilities = discovered_method_visibilities
-      @discovered_superclasses = discovered_superclasses
-      @discovered_includes = discovered_includes
+      @discovery = discovery
       @indexed_narrowings = indexed_narrowings
       @method_chain_narrowings = method_chain_narrowings
       @source_path = source_path
@@ -127,6 +127,8 @@ module Rigor
     end
 
     def with_local(name, type)
+      # `rigor trace` — the moment a local enters the scope.
+      Inference::FlowTracer.bind(name, type) if Inference::FlowTracer.active?
       new_locals = @locals.merge(name.to_sym => type).freeze
       new_fact_store = fact_store.invalidate_target(Analysis::FactStore::Target.local(name))
       # Rebinding `name` invalidates every "after `receiver[key]
@@ -160,28 +162,19 @@ module Rigor
     # ADR-11 per-call-site assertion gating prerequisite. The
     # analyzer's per-file boundary stamps the current source
     # file's path onto the seed scope; nested rebuilds carry
-    # the value through so plugin hooks like
-    # `flow_contribution_for` can resolve "which file does
-    # this call site belong to?" without thread-locals.
+    # the value through so plugin rules (`dynamic_return`'s
+    # `file_methods:` gate, sigil checks) can resolve "which
+    # file does this call site belong to?" without
+    # thread-locals.
     def with_source_path(path)
       rebuild(source_path: path)
     end
 
-    # Slice A-declarations. Returns a scope that carries an
-    # identity-comparing Hash of `Prism::Node => Rigor::Type`
-    # overrides. `ExpressionTyper#type_of(node)` MUST consult
-    # `declared_types[node]` before any other dispatch and
-    # return the recorded type as-is when present. The table is
-    # populated by `ScopeIndexer` for declaration-position
-    # nodes (the `constant_path` of `Prism::ModuleNode` and
-    # `Prism::ClassNode`) so a `module Foo` / `class Bar`
-    # header types as `Singleton[<qualified path>]` instead of
-    # falling through to `Dynamic[Top]`. The table is shared
-    # by structural reference across every derived scope so
-    # `with_local` / `with_fact` / `with_self_type` carry it
-    # transparently.
-    def with_declared_types(table)
-      rebuild(declared_types: table)
+    # ADR-53 Track A — swaps the whole discovery index in one transition.
+    # The sole seeding path; the per-table writers it replaced are derived
+    # off-`Scope` through `scope.discovery.with(table_name: table)`.
+    def with_discovery(index)
+      rebuild(discovery: index)
     end
 
     # Slice 7 phase 1 — instance/class/global variable bindings.
@@ -237,11 +230,7 @@ module Rigor
     def class_ivars_for(class_name)
       return EMPTY_VAR_BINDINGS if class_name.nil?
 
-      @class_ivars[class_name.to_s] || EMPTY_VAR_BINDINGS
-    end
-
-    def with_class_ivars(table)
-      rebuild(class_ivars: table)
+      @discovery.class_ivars[class_name.to_s] || EMPTY_VAR_BINDINGS
     end
 
     # Slice 7 phase 6 — class-level cvar accumulator (same shape
@@ -251,48 +240,7 @@ module Rigor
     def class_cvars_for(class_name)
       return EMPTY_VAR_BINDINGS if class_name.nil?
 
-      @class_cvars[class_name.to_s] || EMPTY_VAR_BINDINGS
-    end
-
-    def with_class_cvars(table)
-      rebuild(class_cvars: table)
-    end
-
-    # Slice 7 phase 6 — program-level globals accumulator.
-    # Globals are process-wide in Ruby, so the analyzer carries a
-    # single map (`Hash[Symbol, Type]`) keyed by the variable name
-    # and seeded into every method body (instance and singleton)
-    # plus the top-level program scope. `ScopeIndexer` populates
-    # it from a single program-wide pre-pass.
-    def with_program_globals(table)
-      rebuild(program_globals: table)
-    end
-
-    # Slice 7 phase 7 — in-source class discovery. Maps a
-    # qualified class name (e.g. `"Account"`) to its
-    # `Type::Singleton` so references to user-defined classes
-    # in the analyzed files resolve through
-    # `ExpressionTyper#resolve_constant_name` even when no RBS
-    # decl exists. Populated once at index time by
-    # `ScopeIndexer` from every `Prism::ClassNode` and
-    # `Prism::ModuleNode` it walks.
-    def with_discovered_classes(table)
-      rebuild(discovered_classes: table)
-    end
-
-    # Slice 7 phase 9 — in-source constant-value tracking.
-    # Maps a qualified constant name (e.g. `"BUCKETS"` or
-    # `"Rigor::Analysis::FactStore::BUCKETS"`) to the type of
-    # the rvalue assigned at its `Prism::ConstantWriteNode` /
-    # `Prism::ConstantPathWriteNode`. Populated by
-    # `ScopeIndexer` once at index time. `ExpressionTyper#resolve_constant_name`
-    # consults this map after class lookups so an in-source
-    # constant assignment overrides any RBS-declared constant
-    # of the same qualified name (matching Ruby's runtime
-    # precedence: a constant defined in user code is the
-    # authoritative value).
-    def with_in_source_constants(table)
-      rebuild(in_source_constants: table)
+      @discovery.class_cvars[class_name.to_s] || EMPTY_VAR_BINDINGS
     end
 
     # Slice 7 phase 12 — in-source method discovery. Maps a
@@ -305,7 +253,7 @@ module Rigor
     # user has defined dynamically, even when no RBS sig
     # describes them.
     def discovered_method?(class_name, method_name, kind)
-      table = @discovered_methods[class_name.to_s]
+      table = @discovery.discovered_methods[class_name.to_s]
       return false unless table
 
       table[method_name.to_sym] == kind
@@ -325,10 +273,6 @@ module Rigor
       @self_type.nil?
     end
 
-    def with_discovered_methods(table)
-      rebuild(discovered_methods: table)
-    end
-
     # v0.0.2 #5 — per-class table mapping
     # `method_name (Symbol) → Prism::DefNode`. Populated by
     # `ScopeIndexer` alongside `discovered_methods` for
@@ -339,11 +283,30 @@ module Rigor
     # inference when the receiver class is user-defined and
     # has no RBS sig.
     def user_def_for(class_name, method_name)
-      table = @discovered_def_nodes[class_name.to_s]
-      return nil unless table
-
-      table[method_name.to_sym]
+      table = @discovery.discovered_def_nodes[class_name.to_s]
+      node = table && table[method_name.to_sym]
+      record_cross_file_method(class_name, method_name, node) if Analysis::DependencyRecorder.active?
+      node
+    end
+
+    # ADR-46 slice 1 — note the cross-file dependency this resolution
+    # creates: the file defining `class_name#method_name` (the consumer's
+    # analysis reads its body via `infer_user_method_return`), or, when
+    # unresolved, a negative edge so a later definition re-checks the
+    # consumer. Gated on the recorder being active — no-op on a normal run.
+    def record_cross_file_method(class_name, method_name, node)
+      if node
+        # ADR-46 slice 4 — pass the symbol so the recorder tracks this as a
+        # method-call (symbol-granularity) edge rather than a file-level edge.
+        Analysis::DependencyRecorder.read_site(
+          @discovery.discovered_def_sources.dig(class_name.to_s, method_name.to_sym),
+          "#{class_name}##{method_name}"
+        )
+      else
+        Analysis::DependencyRecorder.read_missing(:method, "#{class_name}##{method_name}")
+      end
     end
+    private :record_cross_file_method
 
     # v0.0.3 A — top-level def lookup for implicit-self
     # calls. Returns the `Prism::DefNode` for a top-level
@@ -353,15 +316,32 @@ module Rigor
     # consumers should treat its presence as an opaque
     # implementation detail and go through this accessor.
     def top_level_def_for(method_name)
-      table = @discovered_def_nodes[Inference::ScopeIndexer::TOP_LEVEL_DEF_KEY]
-      return nil unless table
-
-      table[method_name.to_sym]
-    end
-
-    def with_discovered_def_nodes(table)
-      rebuild(discovered_def_nodes: table)
+      table = @discovery.discovered_def_nodes[Inference::ScopeIndexer::TOP_LEVEL_DEF_KEY]
+      node = table && table[method_name.to_sym]
+      record_cross_file_toplevel(method_name, node) if Analysis::DependencyRecorder.active?
+      node
+    end
+
+    # ADR-46 slice 3 — a top-level (`def helper` outside any class) call has
+    # NO class ancestry to walk, so unlike {#user_def_for} a miss here records
+    # no positive ancestry edge that would re-check the consumer when the
+    # method later appears. Record the cross-file edge explicitly: the file
+    # defining the top-level method (symbol-granularity, so a body / removal
+    # edit re-checks the caller), or, on a miss, a negative `toplevel:` edge
+    # so a later top-level definition re-checks this consumer (the
+    # `call.unresolved-toplevel` stale-diagnostic gap).
+    def record_cross_file_toplevel(method_name, node)
+      key = Inference::ScopeIndexer::TOP_LEVEL_DEF_KEY
+      if node
+        Analysis::DependencyRecorder.read_site(
+          @discovery.discovered_def_sources.dig(key, method_name.to_sym),
+          "#{key}##{method_name}"
+        )
+      else
+        Analysis::DependencyRecorder.read_missing(:toplevel, method_name)
+      end
     end
+    private :record_cross_file_toplevel
 
     # Companion to {#user_def_for}: returns the `"path:line"` where
     # the project defines `class_name#method_name` (instance-side),
@@ -374,16 +354,12 @@ module Rigor
     # can point at `pre_eval:` (ADR-17) instead of reading as a bare
     # unresolved call.
     def user_def_site_for(class_name, method_name)
-      table = @discovered_def_sources[class_name.to_s]
+      table = @discovery.discovered_def_sources[class_name.to_s]
       return nil unless table
 
       table[method_name.to_sym]
     end
 
-    def with_discovered_def_sources(table)
-      rebuild(discovered_def_sources: table)
-    end
-
     # ADR-24 slice 2 — per-class table mapping a fully
     # qualified user-class name to its superclass name AS
     # WRITTEN at the `class Foo < Bar` declaration (`"Bar"`,
@@ -395,11 +371,25 @@ module Rigor
     # The as-written name is resolved to a qualified class at
     # walk time against the call's lexical nesting.
     def superclass_of(class_name)
-      @discovered_superclasses[class_name.to_s]
-    end
-
-    def with_discovered_superclasses(table)
-      rebuild(discovered_superclasses: table)
+      record_class_dependency(class_name) if Analysis::DependencyRecorder.active?
+      @discovery.discovered_superclasses[class_name.to_s]
+    end
+
+    # ADR-48 — per-class table mapping a fully qualified class name to its
+    # ordered `Data.define` / `Struct.new` member-name list. Populated by
+    # `ScopeIndexer` for both the constant-assigned form
+    # (`Point = Data.define(:x, :y)`) and the named-subclass form
+    # (`class Point < Data.define(:x, :y)`). Consumed by
+    # {Inference::MethodDispatcher::DataFolding} so `Point.new(...)` on a
+    # `Singleton[Point]` receiver materialises a precise member instance.
+    # Returns nil when the class has no recorded layout.
+    def data_member_layout(class_name)
+      layout = @discovery.data_member_layouts[class_name.to_s]
+      # Record the ancestry dependency only on a hit — DataFolding consults
+      # this for every `Singleton[*].new`, and a miss (the common case: an
+      # ordinary class) must not manufacture a spurious cross-file edge.
+      record_class_dependency(class_name) if layout && Analysis::DependencyRecorder.active?
+      layout
     end
 
     # ADR-24 slice 2 — per-class/module table mapping a fully
@@ -412,12 +402,25 @@ module Rigor
     # `def`s, not just the superclass chain. As-written names
     # are resolved to qualified classes at walk time.
     def includes_of(class_name)
-      @discovered_includes[class_name.to_s] || []
+      record_class_dependency(class_name) if Analysis::DependencyRecorder.active?
+      @discovery.discovered_includes[class_name.to_s] || []
     end
 
-    def with_discovered_includes(table)
-      rebuild(discovered_includes: table)
+    # Records, for a resolved cross-class ancestry read, every file that
+    # declares `class_name` (its declaration / reopening / superclass /
+    # include sites). The `discovered_class_sources` table it reads is
+    # populated only by the cross-file project pre-pass
+    # ({Inference::ScopeIndexer.discovered_def_index_for_paths}) and only
+    # when dependency recording is active. No-op when the class is not a
+    # project class (core / stdlib / gem names never appear in the source
+    # map). Gated by the caller on the recorder being active.
+    def record_class_dependency(class_name)
+      sites = @discovery.discovered_class_sources[class_name.to_s]
+      return if sites.nil?
+
+      sites.each { |site| Analysis::DependencyRecorder.read_site(site) }
     end
+    private :record_class_dependency
 
     # v0.1.2 — per-class table mapping `method_name (Symbol) →
     # :public | :private | :protected`. Populated by
@@ -429,16 +432,12 @@ module Rigor
     # so explicit-non-self calls to a private method surface
     # a diagnostic.
     def discovered_method_visibility(class_name, method_name)
-      table = @discovered_method_visibilities[class_name.to_s]
+      table = @discovery.discovered_method_visibilities[class_name.to_s]
       return nil unless table
 
       table[method_name.to_sym]
     end
 
-    def with_discovered_method_visibilities(table)
-      rebuild(discovered_method_visibilities: table)
-    end
-
     # Closes the "`params[:f] ||= []; params[:f] << x`" precision
     # gap (ROADMAP § Type-language / engine — indexed-collection
     # narrowing through `Hash[k] ||= default`). After
@@ -577,14 +576,8 @@ module Rigor
 
     def rebuild(
       locals: @locals, fact_store: @fact_store, self_type: @self_type,
-      declared_types: @declared_types, ivars: @ivars, cvars: @cvars, globals: @globals,
-      class_ivars: @class_ivars, class_cvars: @class_cvars, program_globals: @program_globals,
-      discovered_classes: @discovered_classes, in_source_constants: @in_source_constants,
-      discovered_methods: @discovered_methods, discovered_def_nodes: @discovered_def_nodes,
-      discovered_def_sources: @discovered_def_sources,
-      discovered_method_visibilities: @discovered_method_visibilities,
-      discovered_superclasses: @discovered_superclasses,
-      discovered_includes: @discovered_includes,
+      ivars: @ivars, cvars: @cvars, globals: @globals,
+      discovery: @discovery,
       indexed_narrowings: @indexed_narrowings,
       method_chain_narrowings: @method_chain_narrowings,
       source_path: @source_path
@@ -592,18 +585,8 @@ module Rigor
       self.class.new(
         environment: environment, locals: locals,
         fact_store: fact_store, self_type: self_type,
-        declared_types: declared_types,
         ivars: ivars, cvars: cvars, globals: globals,
-        class_ivars: class_ivars, class_cvars: class_cvars,
-        program_globals: program_globals,
-        discovered_classes: discovered_classes,
-        in_source_constants: in_source_constants,
-        discovered_methods: discovered_methods,
-        discovered_def_nodes: discovered_def_nodes,
-        discovered_def_sources: discovered_def_sources,
-        discovered_method_visibilities: discovered_method_visibilities,
-        discovered_superclasses: discovered_superclasses,
-        discovered_includes: discovered_includes,
+        discovery: discovery,
         indexed_narrowings: indexed_narrowings,
         method_chain_narrowings: method_chain_narrowings,
         source_path: source_path
@@ -611,8 +594,19 @@ module Rigor
     end
 
     def join_bindings(left, right)
-      shared = left.keys & right.keys
-      shared.to_h { |name| [name, Type::Combinator.union(left[name], right[name])] }.freeze
+      # Keys present in both, unioned. Iterating `left` and probing
+      # `right.key?` yields the same keys in the same order as the prior
+      # `(left.keys & right.keys)` while avoiding the two key arrays and
+      # the intersection array — this is the control-flow join, run at
+      # every branch merge, and was a top allocation site (~75% of
+      # `Hash#keys`).
+      result = {}
+      left.each do |name, ltype|
+        next unless right.key?(name)
+
+        result[name] = Type::Combinator.union(ltype, right[name])
+      end
+      result.freeze
     end
 
     def build_joined_scope(joined_locals, joined_ivars, joined_cvars, joined_globals, other)
@@ -621,21 +615,10 @@ module Rigor
         locals: joined_locals.freeze,
         fact_store: fact_store.join(other.fact_store),
         self_type: self_type == other.self_type ? self_type : nil,
-        declared_types: declared_types,
         ivars: joined_ivars,
         cvars: joined_cvars,
         globals: joined_globals,
-        class_ivars: class_ivars,
-        class_cvars: class_cvars,
-        program_globals: program_globals,
-        discovered_classes: discovered_classes,
-        in_source_constants: in_source_constants,
-        discovered_methods: discovered_methods,
-        discovered_def_nodes: discovered_def_nodes,
-        discovered_def_sources: discovered_def_sources,
-        discovered_method_visibilities: discovered_method_visibilities,
-        discovered_superclasses: discovered_superclasses,
-        discovered_includes: discovered_includes,
+        discovery: @discovery,
         indexed_narrowings: join_bindings(@indexed_narrowings, other.indexed_narrowings),
         method_chain_narrowings: join_bindings(@method_chain_narrowings, other.method_chain_narrowings),
         source_path: source_path

data/lib/rigor/sig_gen/observation_collector.rb

@@ -96,7 +96,8 @@ module Rigor
         parse_result = Prism.parse(source, filepath: path, version: @configuration.target_ruby)
         return if parse_result.errors.any?
 
-        base_scope = Scope.empty(environment: environment).with_discovered_classes(discovered_classes)
+        base_scope = Scope.empty(environment: environment)
+        base_scope = base_scope.with_discovery(base_scope.discovery.with(discovered_classes: discovered_classes))
         scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: base_scope)
         bindings = collect_rspec_bindings(parse_result.value, scope_index)
 
@@ -104,11 +105,10 @@ module Rigor
       end
 
       # Pre-walks `@source_paths` to collect every qualified
-      # class / module declaration. The result feeds
-      # `Scope#with_discovered_classes` for each observe-tree
-      # scope so `Foo.new` and `Foo` resolve to the right
-      # singleton carrier even when no RBS sig describes
-      # `Foo` yet.
+      # class / module declaration. The result seeds the
+      # `discovered_classes` table on each observe-tree scope so
+      # `Foo.new` and `Foo` resolve to the right singleton carrier
+      # even when no RBS sig describes `Foo` yet.
       def preindex_source_classes
         accumulator = {}
         resolve_paths(@source_paths).each { |path| harvest_classes_from(path, accumulator) }

data/lib/rigor/source/literals.rb

@@ -100,6 +100,20 @@ module Rigor
         args.filter_map { |arg| symbol_or_string(arg) }
       end
 
+      # Whether a node is a literal `Prism::SymbolNode` that names `name`.
+      # The key-comparison counterpart to {.symbol_name} — for callers
+      # that need a predicate rather than an extraction (hash-key matching
+      # in keyword or assoc argument positions, e.g.
+      # `el.is_a?(AssocNode) && symbol_named?(el.key, "required")`).
+      # Uses `#unescaped` (not `#value`) for round-trip consistency.
+      #
+      # @param node [Prism::Node, nil]
+      # @param name [String]
+      # @return [Boolean]
+      def symbol_named?(node, name)
+        node.is_a?(Prism::SymbolNode) && node.unescaped == name
+      end
+
       # The literal Symbol/String at positional `index`, or `nil` when the
       # call has no argument list, the index is out of range, or the
       # argument there is not a literal Symbol/String.

data/lib/rigor/type/acceptance_router.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Type
+    # Routes `accepts` through the engine's acceptance dispatcher.
+    #
+    # Every carrier's acceptance check is the same fixed forwarding on
+    # `self` — `Inference::Acceptance.accepts(self, other, mode: mode)` —
+    # so it lived as an identical copy in fourteen carriers. The one
+    # exception is `Type::App`, which forwards on its reduced `bound`
+    # type rather than `self`; it keeps its own `accepts` and does not
+    # include this.
+    module AcceptanceRouter
+      def accepts(other, mode: :gradual)
+        Inference::Acceptance.accepts(self, other, mode: mode)
+      end
+    end
+  end
+end