rigortype 0.1.17 → 0.1.18

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/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

@@ -109,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
@@ -117,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/scope.rbs

@@ -4,27 +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 discovered_class_sources: Hash[String, Set[String]]
-    attr_reader data_member_layouts: Hash[String, Array[Symbol]]
+    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
@@ -39,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?
@@ -50,29 +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 with_data_member_layouts: (Hash[String, Array[Symbol]] table) -> Scope
     def includes_of: (String | Symbol class_name) -> Array[String]
-    def with_discovered_includes: (Hash[String, Array[String]] table) -> Scope
-    def with_discovered_class_sources: (Hash[String, Set[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
@@ -83,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