rigortype 0.1.16 → 0.1.18

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/catalog.rb

@@ -6,7 +6,7 @@ module Rigor
       # Per-run table of method signatures keyed by the
       # `(class_name, method_name, kind)` triple. Built by
       # {CatalogWalker} during the plugin's lazy pre-walk; read
-      # by {Sorbet#flow_contribution_for} at every call site.
+      # by the plugin's `dynamic_return` rule at every gated call site.
       #
       # The catalog is mutable while it is being built, then
       # frozen via {#freeze!} before the first read. Construction
@@ -80,6 +80,22 @@ module Rigor
           @entries.empty?
         end
 
+        # ADR-52 slice 4 — the distinct method names the catalog
+        # carries at least one signature for, across every
+        # `(class_name, kind)` owner. Feeds the plugin's run-time
+        # `dynamic_return methods:` name gate: the engine only
+        # consults the plugin for a call whose name appears here
+        # (or in the static assertion vocabulary), and the
+        # precise `(class, kind)` lookup stays in the rule block.
+        # Computed fresh per call — the plugin memoises the
+        # resolved set, and `freeze!` freezes the catalog itself
+        # so a lazy memo ivar here would raise.
+        #
+        # @return [Array<Symbol>]
+        def method_names
+          @entries.keys.map { |key| key[1] }.uniq
+        end
+
         def size
           @entries.size
         end

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/sigil_detector.rb

@@ -24,8 +24,8 @@ module Rigor
       # identically — per-call-site sigil honouring (e.g. only
       # firing `T.let` recognition in `# typed: true`+ files)
       # requires threading the file path through
-      # `flow_contribution_for`, which lives behind a future
-      # plugin-contract widening slice.
+      # the per-call recognition path, which lives behind a
+      # future plugin-contract widening slice.
       module SigilDetector
         # Sorbet's strictness-level names. Stored as symbols to
         # match the analyzer's existing convention for level

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet.rb

@@ -39,8 +39,8 @@ module Rigor
     # access by walking every configured `paths:` entry's `.rb`
     # files plus every `rbi_paths:` entry's `.rbi` files (slice
     # 4) via the plugin's `IoBoundary`. The catalog is frozen
-    # after the first build and consulted by
-    # `#flow_contribution_for` at every call site. RBI files
+    # after the first build and consulted by the `dynamic_return`
+    # rule at every gated call site. RBI files
     # share the catalog with project-source sigs — both produce
     # `MethodSignature` entries keyed by
     # `(class_name, method_name, kind)`. When a key collides
@@ -101,7 +101,7 @@ module Rigor
         @enforce_sigil = config.fetch("enforce_sigil")
         # ADR-11 deferred follow-up — per-call-site assertion
         # gating. Catalog harvest's `@sigil_by_path` cache is
-        # consulted at every `flow_contribution_for` call so
+        # consulted at every per-call recognition so
         # `T.let` / `T.cast` / `T.must` / `T.bind` /
         # `T.assert_type!` only fire in files Sorbet itself
         # would enforce (`# typed: true` / `:strict` /
@@ -118,7 +118,7 @@ module Rigor
         @parse_errors_by_path = {}
         @catalog_built = false
         # ADR-11 slice 6 — Prism nodes for `T.absurd` calls
-        # we observed in `flow_contribution_for` to be
+        # we observed in the `dynamic_return` rule to be
         # *reachable* (i.e., their discriminant didn't narrow
         # to `bot`). `diagnostics_for_file` walks the per-file
         # AST and surfaces these as `plugin.sorbet.absurd-reachable`
@@ -128,7 +128,7 @@ module Rigor
         # plugin hooks.
         @reachable_absurd_nodes = {}.compare_by_identity
         # ADR-11 light follow-up — `T.reveal_type` calls
-        # observed in `flow_contribution_for`, paired with the
+        # observed in the `dynamic_return` rule, paired with the
         # display string for the inferred type at the call site.
         # Mirrors the absurd-node compare-by-identity hash;
         # `diagnostics_for_file` surfaces each entry as a
@@ -136,7 +136,7 @@ module Rigor
         @reveal_type_calls = {}.compare_by_identity
         # T.bind / T.assert_type! priority slice 1 —
         # `T.assert_type!` calls observed in
-        # `flow_contribution_for` whose static subtype check
+        # the `dynamic_return` rule whose static subtype check
         # FAILED, paired with the inferred + asserted type
         # display strings. Same compare-by-identity discipline.
         # `diagnostics_for_file` walks the file AST for
@@ -160,9 +160,52 @@ module Rigor
         diagnostics
       end
 
-      # ADR-11 slice 1 — return-type contribution from the
-      # parsed `sig { ... }` block. Resolves the receiver in two
-      # passes:
+      # ADR-52 slice 4 — the per-call return-type path, migrated off
+      # the legacy `flow_contribution_for` hook onto the
+      # method-name-gated `dynamic_return` DSL. The recognised name
+      # set is only known at run time (the catalog's `def` names come
+      # from the lazy catalog build), so it is declared as a
+      # callable: the engine `instance_exec`s it once per run on
+      # first dispatch (always after `#prepare`) and memoises the
+      # resolved Symbol Set. The gate is a safe over-approximation —
+      # a project method merely *named* `cast` or `find` passes it
+      # and is declined by the block's own `T.`-receiver / catalog
+      # checks, exactly as the ungated hook used to decline.
+      dynamic_return methods: -> { recognised_method_names } do |call_node, scope|
+        contribution_return_type(call_node, scope)
+      end
+
+      # ADR-52 slice 4 — `T.bind(self, T)`'s self-narrowing fact,
+      # migrated off the legacy hook's `post_return_facts` slot onto
+      # the method-gated `type_specifier` DSL (once
+      # `flow_contribution_for` is gone, the statement evaluator
+      # consults only this path for narrowing facts). The
+      # return-type half (`Constant[nil]`) flows through the
+      # `dynamic_return` rule above; the block re-checks the `T.`
+      # receiver via the recogniser, so an unrelated `bind` call
+      # contributes nothing.
+      type_specifier methods: [:bind] do |call_node, scope|
+        bind_post_return_facts(call_node, scope)
+      end
+
+      private
+
+      # ADR-52 slice 4 — the run-time method-name gate for the
+      # `dynamic_return` rule: the static assertion vocabulary
+      # (`T.let` / `T.cast` / …), `T.absurd`, and every method name
+      # the catalog carries a sig for.
+      def recognised_method_names
+        ensure_catalog
+        names = AssertionRecognizer::SORBET_ASSERTIONS.dup
+        names << :absurd
+        names.concat(@catalog.method_names)
+        names
+      end
+
+      # The migrated body of the legacy `flow_contribution_for` —
+      # same recognition order, but returns the bare `Rigor::Type`
+      # the `dynamic_return` contract expects. Resolves the receiver
+      # in two passes:
       #
       # 1. Constant receiver (`User.find(...)`) → singleton-side
       #    catalog lookup.
@@ -173,18 +216,22 @@ module Rigor
       # Implicit-self calls (no receiver, current-class method)
       # are deferred to slice 2 — slice 1 covers the common case
       # where the sig is on the called method's own class.
-      def flow_contribution_for(call_node:, scope:)
+      def contribution_return_type(call_node, scope)
         return nil unless call_node.is_a?(Prism::CallNode)
 
         # ADR-11 slice 6 — `T.absurd(x)` exhaustiveness. Always
-        # contributes a `bot` return + raise effect (matches
-        # Sorbet's runtime behaviour); when the discriminant
-        # *isn't* narrowed to `bot` at this scope, also records
-        # the call node so `diagnostics_for_file` can surface a
-        # `plugin.sorbet.absurd-reachable` warning.
+        # contributes a `bot` return (matches Sorbet's runtime
+        # behaviour: `T.absurd` raises, so its value type is `bot`
+        # and the engine's flow analysis treats code after it as
+        # unreachable; the legacy contribution's `exceptional:
+        # :raises` slot was never consumed on the dispatcher path —
+        # only `return_type` survives the merge). When the
+        # discriminant *isn't* narrowed to `bot` at this scope, also
+        # records the call node so `diagnostics_for_file` can surface
+        # a `plugin.sorbet.absurd-reachable` warning.
         if AbsurdRecognizer.absurd_call?(call_node)
           @reachable_absurd_nodes[call_node] = true unless AbsurdRecognizer.exhaustive?(call_node, scope)
-          return AbsurdRecognizer.contribution(call_node, manifest.id)
+          return Rigor::Type::Combinator.bot
         end
 
         # ADR-11 slice 2 — `T.let` / `T.cast` / `T.must` /
@@ -214,31 +261,31 @@ module Rigor
           if assertion
             record_reveal_type_call(call_node, assertion.return_type) if call_node.name == :reveal_type
             record_assert_type_check(call_node, scope) if call_node.name == :assert_type!
-            return assertion
+            return assertion.return_type
           end
         end
 
         return nil if @catalog.nil? || @catalog.empty?
 
-        signature = lookup_signature(call_node, scope)
-        return nil if signature.nil?
+        lookup_signature(call_node, scope)&.return_type
+      end
 
-        return_type = signature.return_type
-        return nil if return_type.nil?
+      # The `type_specifier` body for `T.bind` — same sigil gate as
+      # the return-type path, then the recogniser's
+      # `post_return_facts` (the `Fact(target_kind: :self)` that
+      # narrows `scope.self_type` for the rest of the block).
+      def bind_post_return_facts(call_node, scope)
+        return nil unless call_node.is_a?(Prism::CallNode)
 
-        Rigor::FlowContribution.new(
-          return_type: return_type,
-          provenance: Rigor::FlowContribution::Provenance.new(
-            source_family: "plugin.#{manifest.id}",
-            plugin_id: manifest.id,
-            node: call_node,
-            descriptor: nil
-          )
+        ensure_catalog
+        return nil unless assertion_enforced_here?(scope)
+
+        contribution = AssertionRecognizer.recognize(
+          call_node: call_node, scope: scope, plugin_id: manifest.id
         )
+        contribution&.post_return_facts
       end
 
-      private
-
       # ADR-11 deferred follow-up — per-call-site assertion
       # gating. With `enforce_sigil: false`, the gate is fully
       # open (matches the pre-feature behaviour). With
@@ -441,7 +488,7 @@ module Rigor
         # magic comment by skipping the file entirely.
         level = SigilDetector.detect(contents)
         # Per-call-site assertion gating consults this map at
-        # `flow_contribution_for`. Recorded BEFORE the ignored
+        # recognition time. Recorded BEFORE the ignored
         # short-circuit so a `# typed: ignore` file still
         # reports its level to the gate (the gate then chooses
         # to suppress assertions there too — `ignore` is
@@ -481,7 +528,7 @@ module Rigor
       # nodes and emits a `plugin.sorbet.absurd-reachable`
       # warning for any whose object identity matches
       # `@reachable_absurd_nodes` (populated during the engine's
-      # earlier pass through `flow_contribution_for`). Pops
+      # earlier pass through the `dynamic_return` rule). Pops
       # matched entries so a duplicate run doesn't double-emit.
       def absurd_reachable_diagnostics(path, root)
         return [] if @reachable_absurd_nodes.empty?
@@ -569,8 +616,8 @@ module Rigor
       # static subtype check at recogniser time and records the
       # call only when the inferred type is *provably
       # incompatible* with the asserted type. Gradual
-      # consistency rules (`Inference::Acceptance.accepts(...)`
-      # mode `:gradual`): a `Dynamic[top]` inferred type
+      # consistency rules (`Type#accepts` mode `:gradual`): a
+      # `Dynamic[top]` inferred type
       # silences the check; a definite `:no` records for
       # diagnostic emission; `:maybe` (uncertain) is treated as
       # "trust the user" and silenced — the runtime check is
@@ -582,7 +629,7 @@ module Rigor
         inferred, asserted = check
         return if inferred.nil?
 
-        result = Rigor::Inference::Acceptance.accepts(asserted, inferred)
+        result = asserted.accepts(inferred)
         return unless result.no?
 
         @assert_type_mismatches[call_node] = [display_for_type(inferred), display_for_type(asserted)]

data/sig/rigor/cache.rbs

@@ -0,0 +1,19 @@
+module Rigor
+  module Cache
+    # Structural interface for the RBS-derived cache producers: a class
+    # object that responds to `.fetch(loader:, store:)` and yields the
+    # cached (or freshly computed) value. A structural *interface*
+    # (duck-typed), not a "protocol" (reserved for ADR-28). Satisfied by
+    # `RbsCacheProducer` and every subclass; matches the _Type and
+    # _DispatchTier interfaces declared elsewhere in sig/.
+    interface _CacheProducer
+      def fetch: (loader: untyped, store: untyped) -> untyped
+    end
+
+    # Base owning the shared producer `fetch` wiring; subclasses add a
+    # PRODUCER_ID constant and a private `self.compute(loader)`.
+    class RbsCacheProducer
+      def self.fetch: (loader: untyped, store: untyped) -> untyped
+    end
+  end
+end

data/sig/rigor/environment.rbs

@@ -58,10 +58,8 @@ module Rigor
       def rbs_module?: (String | Symbol name) -> bool
       def instance_definition: (String | Symbol class_name) -> untyped?
       def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
-      def uncached_instance_definition: (String | Symbol class_name) -> untyped?
       def singleton_definition: (String | Symbol class_name) -> untyped?
       def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
-      def uncached_singleton_definition: (String | Symbol class_name) -> untyped?
       def class_type_param_names: (String | Symbol class_name) -> Array[Symbol]
       def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
       def constant_type: (String name) -> Type::t?

data/sig/rigor/inference.rbs

@@ -57,6 +57,28 @@ module Rigor
     module MethodDispatcher
       def self?.dispatch: (receiver_type: Type::t?, method_name: Symbol, arg_types: Array[Type::t], ?block_type: Type::t?, ?environment: Environment?) -> Type::t?
       def self?.expected_block_param_types: (receiver_type: Type::t?, method_name: Symbol, arg_types: Array[Type::t], ?environment: Environment?) -> Array[Type::t]
+
+      # Immutable value object threaded through every dispatch tier.
+      class CallContext
+        attr_reader receiver: Type::t?
+        attr_reader method_name: Symbol
+        attr_reader args: Array[Type::t]
+        attr_reader block_type: Type::t?
+        attr_reader environment: Environment?
+        attr_reader call_node: untyped
+        attr_reader scope: untyped
+        attr_reader self_type_override: Type::t?
+        attr_reader public_only: bool
+
+        def self.build: (receiver: Type::t?, method_name: Symbol, args: Array[Type::t], ?block_type: Type::t?, ?environment: Environment?, ?call_node: untyped, ?scope: untyped, ?self_type_override: Type::t?, ?public_only: bool) -> CallContext
+        def with: (**untyped) -> CallContext
+      end
+
+      # The interface every dispatch tier observes: fold one call site,
+      # returning a `Type::t` or nil to defer to the next tier.
+      interface _DispatchTier
+        def try_dispatch: (CallContext) -> Type::t?
+      end
     end
 
     class MethodParameterBinder
@@ -87,6 +109,9 @@ module Rigor
       def self?.narrow_not_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
       def self?.narrow_not_refinement: (Type::t current_type, Type::t refinement_type) -> Type::t
       def self?.narrow_for_fact: (Type::t current, untyped fact, untyped environment) -> Type::t
+      def self?.predicate_certainty: (Type::t? type) -> (:truthy | :falsey | nil)
+      def self?.class_pattern_certainty: (Type::t subject_type, String class_name, environment: Environment) -> (:yes | :no | :maybe)
+      def self?.value_pattern_certainty: (Type::t subject_type, untyped pattern_value) -> (:yes | :no | :maybe)
       def self?.predicate_scopes: (untyped node, Scope scope) -> [Scope, Scope]
       def self?.case_when_scopes: (untyped subject, Array[untyped] conditions, Scope scope) -> [Scope, Scope]
       def self?.analyse: (untyped node, Scope scope) -> untyped
@@ -95,6 +120,8 @@ module Rigor
       def self?.trusted_equality_literal?: (untyped literal) -> bool
       def self?.falsey_value?: (untyped value) -> bool
       def self?.falsey_nominal?: (Type::Nominal nominal) -> bool
+
+      VALUE_EQUALITY_CLASSES: Array[Class]
     end
 
     module ClosureEscapeAnalyzer

data/sig/rigor/plugin/base.rbs

@@ -23,7 +23,7 @@ class Rigor::Plugin::Base
   def self.node_file_context: () { (untyped root, untyped scope) -> untyped } -> untyped
   def self.node_file_context_block: () -> untyped
 
-  def self.dynamic_return: (receivers: Array[String]) { (untyped call_node, untyped scope) -> untyped } -> nil
+  def self.dynamic_return: (?receivers: (Array[String] | ^() -> Array[String])?, ?methods: (Array[untyped] | ^() -> Array[untyped])?) { (untyped call_node, untyped scope) -> untyped } -> nil
   def self.dynamic_returns: () -> Array[untyped]
 
   def self.type_specifier: (methods: Array[untyped]) { (untyped call_node, untyped scope) -> untyped } -> nil
@@ -41,7 +41,6 @@ class Rigor::Plugin::Base
   # Overridable lifecycle / extension hooks (default no-ops).
   def init: (untyped services) -> nil
   def prepare: (untyped services) -> nil
-  def flow_contribution_for: (call_node: untyped, scope: untyped) -> untyped
   def diagnostics_for_file: (path: untyped, scope: untyped, root: untyped) -> Array[untyped]
 
   # Engine-executed dispatch over the declared DSLs.

data/sig/rigor/rbs_extended.rbs

@@ -45,6 +45,8 @@ module Rigor
 
     def self?.read_flow_contribution: (untyped method_def) -> untyped?
 
+    def self?.parse_conforms_to_annotation: (String? string) -> String?
+
     class ParamOverride
       attr_reader param_name: Symbol
       attr_reader type: Type::t

data/sig/rigor/scope.rbs

@@ -4,25 +4,52 @@ module Rigor
     attr_reader locals: Hash[Symbol, Type::t]
     attr_reader fact_store: Analysis::FactStore
     attr_reader self_type: Type::t?
-    attr_reader declared_types: Hash[untyped, Type::t]
     attr_reader ivars: Hash[Symbol, Type::t]
     attr_reader cvars: Hash[Symbol, Type::t]
     attr_reader globals: Hash[Symbol, Type::t]
-    attr_reader class_ivars: Hash[String, Hash[Symbol, Type::t]]
-    attr_reader class_cvars: Hash[String, Hash[Symbol, Type::t]]
-    attr_reader program_globals: Hash[Symbol, Type::t]
-    attr_reader discovered_classes: Hash[String, Type::Singleton]
-    attr_reader in_source_constants: Hash[String, Type::t]
-    attr_reader discovered_methods: Hash[String, Hash[Symbol, Symbol]]
-    attr_reader discovered_def_nodes: Hash[String, Hash[Symbol, untyped]]
-    attr_reader discovered_def_sources: Hash[String, Hash[Symbol, String]]
-    attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
-    attr_reader discovered_superclasses: Hash[String, String]
-    attr_reader discovered_includes: Hash[String, Array[String]]
+    attr_reader discovery: DiscoveryIndex
     attr_reader indexed_narrowings: Hash[IndexedKey, Type::t]
     attr_reader method_chain_narrowings: Hash[ChainKey, Type::t]
     attr_reader source_path: String?
 
+    # ADR-53 Track A — the seed-time discovery tables live on the
+    # DiscoveryIndex; Scope keeps per-table readers as delegates.
+    def declared_types: () -> Hash[untyped, Type::t]
+    def class_ivars: () -> Hash[String, Hash[Symbol, Type::t]]
+    def class_cvars: () -> Hash[String, Hash[Symbol, Type::t]]
+    def program_globals: () -> Hash[Symbol, Type::t]
+    def discovered_classes: () -> Hash[String, Type::Singleton]
+    def in_source_constants: () -> Hash[String, Type::t]
+    def discovered_methods: () -> Hash[String, Hash[Symbol, Symbol]]
+    def discovered_def_nodes: () -> Hash[String, Hash[Symbol, untyped]]
+    def discovered_def_sources: () -> Hash[String, Hash[Symbol, String]]
+    def discovered_method_visibilities: () -> Hash[String, Hash[Symbol, Symbol]]
+    def discovered_superclasses: () -> Hash[String, String]
+    def discovered_includes: () -> Hash[String, Array[String]]
+    def discovered_class_sources: () -> Hash[String, Set[String]]
+    def data_member_layouts: () -> Hash[String, Array[Symbol]]
+
+    class DiscoveryIndex
+      attr_reader declared_types: Hash[untyped, Type::t]
+      attr_reader class_ivars: Hash[String, Hash[Symbol, Type::t]]
+      attr_reader class_cvars: Hash[String, Hash[Symbol, Type::t]]
+      attr_reader program_globals: Hash[Symbol, Type::t]
+      attr_reader discovered_classes: Hash[String, Type::Singleton]
+      attr_reader in_source_constants: Hash[String, Type::t]
+      attr_reader discovered_methods: Hash[String, Hash[Symbol, Symbol]]
+      attr_reader discovered_def_nodes: Hash[String, Hash[Symbol, untyped]]
+      attr_reader discovered_def_sources: Hash[String, Hash[Symbol, String]]
+      attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
+      attr_reader discovered_superclasses: Hash[String, String]
+      attr_reader discovered_includes: Hash[String, Array[String]]
+      attr_reader discovered_class_sources: Hash[String, Set[String]]
+      attr_reader data_member_layouts: Hash[String, Array[Symbol]]
+
+      EMPTY: DiscoveryIndex
+
+      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?data_member_layouts: Hash[String, Array[Symbol]]) -> DiscoveryIndex
+    end
+
     class IndexedKey
       attr_reader receiver_kind: Symbol
       attr_reader receiver_name: Symbol
@@ -37,8 +64,9 @@ module Rigor
 
     def self.empty: (?environment: Environment, ?source_path: String?) -> Scope
 
-    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?declared_types: Hash[untyped, Type::t], ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?source_path: String?) -> void
+    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?discovery: DiscoveryIndex, ?source_path: String?) -> void
     def with_source_path: (String? path) -> Scope
+    def with_discovery: (DiscoveryIndex index) -> Scope
     def local: (String | Symbol name) -> Type::t?
     def ivar: (String | Symbol name) -> Type::t?
     def cvar: (String | Symbol name) -> Type::t?
@@ -48,26 +76,16 @@ module Rigor
     def with_cvar: (String | Symbol name, Type::t type) -> Scope
     def with_global: (String | Symbol name, Type::t type) -> Scope
     def class_ivars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
-    def with_class_ivars: (Hash[String, Hash[Symbol, Type::t]] table) -> Scope
     def class_cvars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
-    def with_class_cvars: (Hash[String, Hash[Symbol, Type::t]] table) -> Scope
-    def with_program_globals: (Hash[Symbol, Type::t] table) -> Scope
-    def with_discovered_classes: (Hash[String, Type::Singleton] table) -> Scope
-    def with_in_source_constants: (Hash[String, Type::t] table) -> Scope
-    def with_discovered_methods: (Hash[String, Hash[Symbol, Symbol]] table) -> Scope
     def discovered_method?: (String | Symbol class_name, String | Symbol method_name, Symbol kind) -> bool
-    def with_discovered_def_nodes: (Hash[String, Hash[Symbol, untyped]] table) -> Scope
-    def with_discovered_def_sources: (Hash[String, Hash[Symbol, String]] table) -> Scope
     def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
     def user_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
     def top_level_def_for: (String | Symbol method_name) -> untyped?
     def toplevel?: () -> bool
-    def with_discovered_method_visibilities: (Hash[String, Hash[Symbol, Symbol]] table) -> Scope
     def discovered_method_visibility: (String | Symbol class_name, String | Symbol method_name) -> Symbol?
     def superclass_of: (String | Symbol class_name) -> String?
-    def with_discovered_superclasses: (Hash[String, String] table) -> Scope
+    def data_member_layout: (String | Symbol class_name) -> Array[Symbol]?
     def includes_of: (String | Symbol class_name) -> Array[String]
-    def with_discovered_includes: (Hash[String, Array[String]] table) -> Scope
     def indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key) -> Type::t?
     def with_indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key, Type::t type) -> Scope
     def without_indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key) -> Scope
@@ -78,7 +96,6 @@ module Rigor
     def without_method_chain_narrowings_for: (Symbol receiver_kind, String | Symbol receiver_name) -> Scope
     def with_fact: (Analysis::FactStore::Fact fact) -> Scope
     def with_self_type: (Type::t? type) -> Scope
-    def with_declared_types: (Hash[untyped, Type::t] table) -> Scope
     def facts_for: (?target: Analysis::FactStore::Target?, ?bucket: Symbol?) -> Array[Analysis::FactStore::Fact]
     def local_facts: (String | Symbol name, ?bucket: Symbol?) -> Array[Analysis::FactStore::Fact]
     def type_of: (untyped node, ?tracer: Inference::FallbackTracer?) -> Type::t

data/sig/rigor/source.rbs

@@ -16,6 +16,7 @@ module Rigor
       def self?.symbol_or_string_name: (untyped? node) -> String?
       def self?.symbol: (untyped? node) -> Symbol?
       def self?.symbol_name: (untyped? node) -> String?
+      def self?.symbol_named?: (untyped? node, String name) -> bool
       def self?.symbol_arguments: (untyped? call_node) -> Array[Symbol]
       def self?.symbol_arg: (untyped? call_node, Integer index) -> Symbol?
     end

data/sig/rigor/type.rbs

@@ -1,9 +1,32 @@
 module Rigor
   module Type
-    type t = Top | Bot | Dynamic | Constant | IntegerRange | Nominal | Singleton | Union | Difference | Tuple | HashShape
+    type t = Top | Bot | Dynamic | Constant | IntegerRange | Nominal | Singleton | Union | Difference | Tuple | HashShape | DataClass | DataInstance
 
     type accepts_mode = :strict | :gradual | :loose
 
+    # The structural interface every `Type::*` carrier satisfies — the
+    # internal type-object API (see
+    # docs/internal-spec/internal-type-api.md). A structural *interface*
+    # (duck-typed: satisfied by having the methods, no `implements`
+    # clause), not a "protocol" — that word is reserved for ADR-28
+    # path-scoped protocol contracts. The closed `type t` union above is
+    # what the engine threads day-to-day; this records the shared
+    # per-carrier method contract in one place. Carriers supply the
+    # identity trio via `Rigor::ValueSemantics` and `accepts` via
+    # `Rigor::Type::AcceptanceRouter`.
+    interface _Type
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
     class Top
       def self.instance: () -> Top
       def describe: (?Symbol verbosity) -> String
@@ -222,6 +245,38 @@ module Rigor
       def inspect: () -> String
     end
 
+    class DataClass
+      attr_reader members: Array[Symbol]
+      attr_reader class_name: String?
+      def initialize: (Array[Symbol] members, ?String? class_name) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class DataInstance
+      attr_reader members: Hash[Symbol, Type::t]
+      attr_reader class_name: String?
+      def initialize: (Hash[Symbol, Type::t] members, ?String? class_name) -> void
+      def member_names: () -> Array[Symbol]
+      def member_type: (Symbol name) -> Type::t?
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
     class AcceptsResult
       attr_reader trinary: Trinary
       attr_reader mode: accepts_mode
@@ -282,6 +337,8 @@ module Rigor
       def self?.universal_int: () -> IntegerRange
       def self?.tuple_of: (*Type::t elements) -> Tuple
       def self?.hash_shape_of: (?Hash[untyped, Type::t]? pairs, **untyped options) -> HashShape
+      def self?.data_class_of: (members: Array[Symbol], ?class_name: String?) -> DataClass
+      def self?.data_instance_of: (members: Hash[Symbol, Type::t], ?class_name: String?) -> DataInstance
       def self?.union: (*Type::t types) -> Type::t
       def self?.key_of: (Type::t type) -> Type::t
       def self?.value_of: (Type::t type) -> Type::t

data/sig/rigor.rbs

@@ -113,8 +113,13 @@ module Rigor
       attr_reader cache_store: untyped
       attr_reader plugin_registry: untyped
       attr_reader buffer: untyped
-      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped, ?workers: Integer, ?collect_stats: bool, ?buffer: untyped, ?prebuilt: untyped, ?environment: untyped) -> void
+      attr_reader file_dependencies: Hash[String, untyped]
+      attr_reader analyzed_files: Array[String]
+      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped, ?workers: Integer, ?collect_stats: bool, ?buffer: untyped, ?prebuilt: untyped, ?environment: untyped, ?record_dependencies: bool, ?analyze_only: untyped) -> void
       def run: (?Array[String] paths) -> Result
+      def run_source: (source: String, ?path: String) -> Result
+      def analysis_file_set: (?Array[String] paths) -> Array[String]
+      def file_dependents: () -> Hash[String, untyped]
       def prepare_project_scan: (?paths: Array[String]) -> untyped
     end
   end