rigortype 0.1.15 → 0.1.16

data/lib/rigor/inference/method_dispatcher/overload_selector.rb

@@ -115,14 +115,31 @@ module Rigor
           # overload-list position.
           overloads = ReceiverAffinity.reorder(overloads, self_type: self_type, environment: environment)
 
-          match = run_selection_passes(
-            overloads, arg_types: arg_types, self_type: self_type, instance_type: instance_type,
-                       type_vars: type_vars, block_required: block_required, param_overrides: param_overrides
-          )
+          passes = lambda do |require_block|
+            run_selection_passes(
+              overloads, arg_types: arg_types, self_type: self_type, instance_type: instance_type,
+                         type_vars: type_vars, block_required: require_block, param_overrides: param_overrides
+            )
+          end
+
+          match = passes.call(block_required)
           return match if match
-          return overloads.find { |mt| overload_has_block?(mt) } if block_required
 
-          # No block at the call site: prefer an overload that does
+          # A block at the call site that no block-declaring overload
+          # matched: Ruby ignores a block handed to a method that never
+          # yields it, so retry treating the block as ignorable rather
+          # than failing the dispatch. Without this, a block-bearing
+          # call to a method whose RBS declares no block (e.g.
+          # `define_command(:x) do … end` against
+          # `def define_command: (Symbol) -> Symbol`) degraded to
+          # `Dynamic[Top]` — and on a self-send suppressed the whole
+          # method's return type.
+          if block_required
+            match = passes.call(false)
+            return match if match
+          end
+
+          # No (usable) block at the call site: prefer an overload that does
           # not REQUIRE a block over `overloads.first`. Methods like
           # `Array#filter` / `Enumerable#map` declare the block-
           # bearing overload first (`() { ... } -> Array[Elem]`) and

data/lib/rigor/inference/method_dispatcher/rbs_dispatch.rb

@@ -64,6 +64,19 @@ module Rigor
       module RbsDispatch
         module_function
 
+        # ADR-43 — ancestor classes whose RBS is authoritative and
+        # COMPLETE, so a call a subclass makes that the ancestor's RBS
+        # does not declare is a genuine mistake rather than a gap.
+        # Membership unlocks inherited-method resolution (and thus
+        # `call.undefined-method`) for Ruby-source subclasses of these
+        # classes; every other RBS ancestor stays on the Dynamic
+        # fallback. Seeded with the plugin contract base — this repo
+        # owns both the class and `sig/rigor/plugin/base.rbs`, and the
+        # `lib` self-check keeps them in lock-step. NOT a place for
+        # third-party/core classes whose objects answer to methods
+        # their RBS omits (`ActionController::Base`, `Hash`, …).
+        ALLOWED_RBS_COMPLETE_ANCESTORS = ["Rigor::Plugin::Base"].freeze
+
         # @param receiver [Rigor::Type]
         # @param method_name [Symbol]
         # @param args [Array<Rigor::Type>]
@@ -94,8 +107,19 @@ module Rigor
         # @return [Rigor::Type, nil] inferred return type, or `nil`
         #   when no rule resolves (no class name, no method, dispatch
         #   on a Top/Dynamic[Top] receiver, etc.).
-        def try_dispatch(receiver:, method_name:, args:, environment:, block_type: nil, self_type_override: nil,
-                         public_only: false)
+        # @param scope [Rigor::Scope, nil] when supplied, enables
+        #   ADR-43 RBS-complete-ancestor resolution: a call on a
+        #   Ruby-source subclass not known to RBS, whose discovered
+        #   superclass chain reaches an allow-listed RBS-complete
+        #   ancestor (e.g. `Rigor::Plugin::Base`), resolves against
+        #   that ancestor's RBS. `nil` (the default for every caller
+        #   that does not thread a scope) keeps the legacy behaviour —
+        #   such an inherited call stays unresolved and degrades to
+        #   `Dynamic[Top]`, which is the false-positive-safe default
+        #   for the open hierarchies (`< ActionController::Base`, …)
+        #   the allow-list deliberately excludes.
+        def try_dispatch(receiver:, method_name:, args:, environment:, block_type: nil, self_type_override: nil, # rubocop:disable Metrics/ParameterLists
+                         public_only: false, scope: nil)
           return nil if environment.nil?
           return nil unless environment.rbs_loader
 
@@ -106,7 +130,8 @@ module Rigor
             environment: environment,
             block_type: block_type,
             self_type_override: self_type_override,
-            public_only: public_only
+            public_only: public_only,
+            scope: scope
           )
         end
 
@@ -148,37 +173,37 @@ module Rigor
         class << self
           private
 
-          def dispatch_for(receiver:, method_name:, args:, environment:, block_type:, self_type_override: nil,
-                           public_only: false)
+          def dispatch_for(receiver:, method_name:, args:, environment:, block_type:, self_type_override: nil, # rubocop:disable Metrics/ParameterLists
+                           public_only: false, scope: nil)
             args ||= []
             case receiver
             when Type::Union
               dispatch_union(receiver, method_name, args, environment, block_type, self_type_override,
-                             public_only: public_only)
+                             public_only: public_only, scope: scope)
             else
               dispatch_one(receiver, method_name, args, environment, block_type, self_type_override,
-                           public_only: public_only)
+                           public_only: public_only, scope: scope)
             end
           end
 
-          def dispatch_union(receiver, method_name, args, environment, block_type, self_type_override = nil,
-                             public_only: false)
+          def dispatch_union(receiver, method_name, args, environment, block_type, self_type_override = nil, # rubocop:disable Metrics/ParameterLists
+                             public_only: false, scope: nil)
             results = receiver.members.map do |member|
               dispatch_one(member, method_name, args, environment, block_type, self_type_override,
-                           public_only: public_only)
+                           public_only: public_only, scope: scope)
             end
             return nil if results.any?(&:nil?)
 
             Type::Combinator.union(*results)
           end
 
-          def dispatch_one(receiver, method_name, args, environment, block_type, self_type_override = nil,
-                           public_only: false)
+          def dispatch_one(receiver, method_name, args, environment, block_type, self_type_override = nil, # rubocop:disable Metrics/ParameterLists
+                           public_only: false, scope: nil)
             descriptor = receiver_descriptor(receiver)
             return nil unless descriptor
 
             class_name, kind, receiver_args = descriptor
-            method_definition = lookup_method(environment, class_name, kind, method_name)
+            method_definition = lookup_method(environment, class_name, kind, method_name, scope)
             return nil unless method_definition
             return nil if public_only && method_private?(method_definition)
 
@@ -267,7 +292,26 @@ module Rigor
               method_definition.accessibility == :private
           end
 
-          def lookup_method(environment, class_name, kind, method_name)
+          def lookup_method(environment, class_name, kind, method_name, scope = nil)
+            direct = lookup_method_on(environment, class_name, kind, method_name)
+            return direct if direct
+
+            # ADR-43 — scoped inherited-method resolution. The direct
+            # lookup misses when `class_name` is a Ruby-source subclass
+            # absent from RBS (so no ancestor walk runs). If its
+            # discovered superclass chain reaches an allow-listed
+            # RBS-complete ancestor, resolve the method there so
+            # inherited contract calls (`self.manifest` on a plugin)
+            # resolve and the normal call rules apply. Bounded to the
+            # allow-list, so open hierarchies stay on the Dynamic
+            # fallback (no false positive on `< ActionController::Base`).
+            ancestor = allowed_rbs_complete_ancestor(environment, class_name, scope)
+            return nil unless ancestor
+
+            lookup_method_on(environment, ancestor, kind, method_name)
+          end
+
+          def lookup_method_on(environment, class_name, kind, method_name)
             case kind
             when :instance
               Rigor::Reflection.instance_method_definition(class_name, method_name, environment: environment)
@@ -276,6 +320,29 @@ module Rigor
             end
           end
 
+          # The first allow-listed, RBS-complete ancestor reachable from
+          # `class_name` through `scope.discovered_superclasses`, or nil.
+          # Returns nil when no scope is threaded, when `class_name` is
+          # itself RBS-known (the direct lookup already had authority),
+          # or when the discovered chain reaches no allow-listed class.
+          # The walk carries a visited set so a malformed cyclic
+          # `A < B < A` source cannot loop.
+          def allowed_rbs_complete_ancestor(environment, class_name, scope)
+            return nil if scope.nil?
+            return nil if Rigor::Reflection.rbs_class_known?(class_name, environment: environment)
+
+            supers = scope.discovered_superclasses
+            seen = {}
+            current = supers[class_name.to_s]
+            until current.nil? || seen[current]
+              return current if ALLOWED_RBS_COMPLETE_ANCESTORS.include?(current)
+
+              seen[current] = true
+              current = supers[current]
+            end
+            nil
+          end
+
           # Slice 4 phase 2d substitution map. Zips the class's
           # declared type-parameter names against the receiver's
           # `type_args`. Returns an empty hash when either side is

data/lib/rigor/inference/method_dispatcher.rb

@@ -71,7 +71,7 @@ module Rigor
       # @param environment [Rigor::Environment, nil] required for
       #   RBS-backed dispatch; when nil only constant folding can fire.
       # @return [Rigor::Type, nil] inferred result type, or `nil` for "no rule".
-      def dispatch(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/MethodLength
+      def dispatch(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
                    block_type: nil, environment: nil,
                    call_node: nil, scope: nil)
         return nil if receiver_type.nil?
@@ -94,7 +94,7 @@ module Rigor
         # consults the registry when both `call_node` and `scope`
         # are supplied — the dispatcher's own internal callers
         # (per-element block fold, etc.) skip this tier.
-        plugin_result = try_plugin_contribution(call_node, scope)
+        plugin_result = try_plugin_contribution(call_node, scope, receiver_type)
         return plugin_result if plugin_result
 
         # ADR-20 slice 3 — Rigor-bundled HKT-builtin return-
@@ -125,7 +125,7 @@ module Rigor
 
         rbs_result = RbsDispatch.try_dispatch(
           receiver: receiver_type, method_name: method_name, args: arg_types,
-          environment: environment, block_type: block_type
+          environment: environment, block_type: block_type, scope: scope
         )
         if rbs_result
           record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
@@ -187,6 +187,19 @@ module Rigor
         discovered_result = try_discovered_method(receiver_type, method_name, scope)
         return discovered_result if discovered_result
 
+        # ADR-5 robustness — synthesized-stub-type tier. When the
+        # receiver is a type Rigor invented to make an otherwise-
+        # unbuildable project signature resolve (a missing-namespace
+        # module, or a stub for a referenced-but-undeclared type like
+        # an unavailable `DRb::DRbServer`), the stub carries no methods,
+        # so an unresolved call against it would otherwise mis-fire
+        # `call.undefined-method`. Resolve it to `Dynamic[Top]` instead
+        # — the same no-false-positive contract as the dependency-
+        # source tier. Sits below every real resolution tier so a
+        # genuine signature always wins.
+        stub_result = try_synthesized_stub_type(receiver_type, environment)
+        return stub_result if stub_result
+
         # Slice 7 phase 10 — user-class ancestor fallback. When
         # the receiver is `Nominal[T]` or `Singleton[T]` for a
         # class not in the RBS environment (typically a
@@ -253,6 +266,31 @@ module Rigor
         end
       end
 
+      # ADR-5 robustness — returns `Dynamic[Top]` when the receiver is
+      # an instance or singleton of a type Rigor synthesized (a
+      # missing-namespace module or a referenced-type stub). The stub
+      # has no methods, so the call would otherwise reach the
+      # user-class fallback and surface `call.undefined-method`; the
+      # honest answer for a type Rigor invented is "unknown shape",
+      # i.e. `Dynamic[Top]`. Returns nil (declines) for any real type.
+      def try_synthesized_stub_type(receiver_type, environment)
+        return nil if environment.nil?
+
+        loader = environment.rbs_loader
+        return nil if loader.nil? || !loader.respond_to?(:synthesized_type_names)
+
+        names = loader.synthesized_type_names
+        return nil if names.empty?
+
+        class_name =
+          case receiver_type
+          when Type::Nominal, Type::Singleton then receiver_type.class_name.to_s.sub(/\A::/, "")
+          end
+        return nil unless class_name && names.include?(class_name)
+
+        Type::Combinator.untyped
+      end
+
       # ADR-2 § "Flow Contribution Bundle" / v0.1.1 Track 2
       # slice 7. Walks every loaded plugin's
       # `#flow_contribution_for(call_node:, scope:)` hook,
@@ -340,13 +378,13 @@ module Rigor
         end
       end
 
-      def try_plugin_contribution(call_node, scope)
+      def try_plugin_contribution(call_node, scope, receiver_type)
         return nil if call_node.nil? || scope.nil?
 
         registry = scope.environment&.plugin_registry
         return nil if registry.nil? || registry.empty?
 
-        contributions = collect_plugin_contributions(registry, call_node, scope)
+        contributions = collect_plugin_contributions(registry, call_node, scope, receiver_type)
         return nil if contributions.empty?
 
         FlowContribution::Merger.merge(contributions).return_type
@@ -622,12 +660,21 @@ module Rigor
         end
       end
 
-      def collect_plugin_contributions(registry, call_node, scope)
-        registry.plugins.filter_map do |plugin|
-          contribution = plugin.flow_contribution_for(call_node: call_node, scope: scope)
-          contribution.is_a?(FlowContribution) ? contribution : nil
+      # ADR-37 slice 2 — gathers each plugin's return-type contribution
+      # from BOTH the narrow `dynamic_return` DSL (receiver-gated, wrapped
+      # as a return-only `FlowContribution`) and the legacy
+      # `flow_contribution_for` escape valve, so migrated and unmigrated
+      # plugins compose through the same merger.
+      def collect_plugin_contributions(registry, call_node, scope, receiver_type)
+        registry.plugins.flat_map do |plugin|
+          contributions = []
+          legacy = plugin.flow_contribution_for(call_node: call_node, scope: scope)
+          contributions << legacy if legacy.is_a?(FlowContribution)
+          dynamic = plugin.dynamic_return_type(call_node: call_node, scope: scope, receiver_type: receiver_type)
+          contributions << FlowContribution.new(return_type: dynamic) if dynamic
+          contributions
         rescue StandardError
-          nil
+          []
         end
       end
 

data/lib/rigor/inference/precision_scanner.rb

@@ -10,7 +10,11 @@ module Rigor
     # engine recognises an AST node class (that is `CoverageScanner`'s job),
     # but whether the type it produces carries useful static information.
     #
-    # Each visited node is classified into one of eight precision tiers:
+    # Each visited *expression* node is classified into one of eight
+    # precision tiers (non-expression syntax nodes — argument /
+    # parameter lists, parameter declarations, hash pairs, statement
+    # wrappers, clause headers — are skipped; see
+    # {NON_EXPRESSION_NODE_TYPES}):
     #
     #   :constant         — Constant[T]: literal value known exactly
     #   :nominal          — Nominal/Singleton: class identity known
@@ -33,6 +37,59 @@ module Rigor
         dynamic_specific dynamic_top top
       ].freeze
 
+      # Prism node classes that do not denote a value-producing
+      # expression, so typing them is meaningless — they have no
+      # runtime value to carry a type. Counting them (they always fall
+      # to the `dynamic_top` fallback) silently diluted the precision
+      # ratio: on a real survey target (shugo/textbringer) they were
+      # ~49% of every "opaque" node, dragging the headline number ~13
+      # points below the true expression-level precision. We exclude
+      # them from BOTH numerator and denominator so the ratio measures
+      # what it claims to — the type quality of actual expressions.
+      #
+      # The set is deliberately CONSERVATIVE: only nodes that are
+      # unambiguously non-expressions in Ruby's grammar are listed —
+      # argument / parameter list containers and the parameter
+      # declarations inside them; the `key => value` pair node (its key
+      # and value are themselves walked and counted); the program /
+      # statements sequence wrappers (their value is the last child,
+      # already counted — listing them avoids double-counting); and the
+      # clause-header nodes whose body, not the header, carries the
+      # value. Anything that *could* be a value expression (`BlockNode`,
+      # `BeginNode`, `ImplicitNode`, `ParenthesesNode`, splats, …) is
+      # left in so a genuine inference gap stays visible.
+      #
+      # Compared by class NAME so a Prism version that lacks one of the
+      # newer node classes does not break loading.
+      NON_EXPRESSION_NODE_TYPES = %w[
+        Prism::ProgramNode
+        Prism::StatementsNode
+        Prism::ArgumentsNode
+        Prism::BlockArgumentNode
+        Prism::ParametersNode
+        Prism::BlockParametersNode
+        Prism::NumberedParametersNode
+        Prism::ItParametersNode
+        Prism::KeywordHashNode
+        Prism::RequiredParameterNode
+        Prism::OptionalParameterNode
+        Prism::RestParameterNode
+        Prism::KeywordRestParameterNode
+        Prism::BlockParameterNode
+        Prism::RequiredKeywordParameterNode
+        Prism::OptionalKeywordParameterNode
+        Prism::ForwardingParameterNode
+        Prism::NoKeywordsParameterNode
+        Prism::ImplicitRestNode
+        Prism::AssocNode
+        Prism::AssocSplatNode
+        Prism::WhenNode
+        Prism::InNode
+        Prism::ElseNode
+        Prism::EnsureNode
+        Prism::RescueNode
+      ].to_set.freeze
+
       TIER_RANK = TIERS.each_with_index.to_h.freeze
       private_constant :TIER_RANK
 
@@ -87,6 +144,8 @@ module Rigor
         total = 0
 
         Source::NodeWalker.each(root) do |node|
+          next if NON_EXPRESSION_NODE_TYPES.include?(node.class.name)
+
           type = scope_index[node].type_of(node)
           tier = classify(type)
           tier_counts[tier] += 1

data/lib/rigor/inference/scope_indexer.rb

@@ -107,7 +107,14 @@ module Rigor
         # introduced method names. `rigor check` consults the
         # table to suppress false positives for methods the
         # user has defined but no RBS sig describes.
-        discovered_methods = build_discovered_methods(root)
+        # Merged UNDER any cross-file pre-pass seed (like the def-node
+        # / include tables below) so a method `def`/`attr_reader`-
+        # declared in one file suppresses a false `undefined-method`
+        # for a call in another — `rigor check` seeds the project-wide
+        # table via `Runner#seed_project_scope`.
+        discovered_methods = deep_merge_class_methods(
+          default_scope.discovered_methods, build_discovered_methods(root)
+        )
         seeded_scope = seeded_scope.with_discovered_methods(discovered_methods)
 
         # v0.0.2 #5 + ADR-24 slice 2 — record per-instance-method
@@ -383,7 +390,7 @@ module Rigor
         # class body has been walked, using `init_writes` as
         # the soundness gate (an ivar written in `initialize`
         # is initialised before any other method body runs).
-        collect_read_before_write_evidence(def_node, class_name, read_before_write, init_writes)
+        collect_read_before_write_evidence(def_node, class_name, read_before_write, init_writes, default_scope)
       end
 
       # Walks the method body in AST (== execution) order
@@ -394,14 +401,21 @@ module Rigor
       # `init_writes` instead — used by the finalisation step
       # to suppress nil contribution for ivars the constructor
       # guarantees are initialised.
-      def collect_read_before_write_evidence(def_node, class_name, read_before_write, init_writes)
+      def collect_read_before_write_evidence(def_node, class_name, read_before_write, init_writes, default_scope = nil)
         return if read_before_write.nil? || init_writes.nil?
 
         seen_writes = Set.new
         read_first = Set.new
         detect_read_before_write(def_node.body, seen_writes, read_first)
 
-        if def_node.name == :initialize
+        # ADR-38 — `initialize` is the built-in initializer gate;
+        # a plugin may declare additional `def`-form initializer
+        # methods (minitest `setup`, Rails `after_initialize`, DI
+        # setters) on a constrained class. Both fold their writes
+        # into `init_writes`, suppressing the read-before-write nil
+        # contribution for sibling readers.
+        if def_node.name == :initialize ||
+           additional_initializer?(class_name, def_node.name, default_scope)
           init_set = (init_writes[class_name] ||= Set.new)
           seen_writes.each { |name| init_set << name }
           return
@@ -413,6 +427,43 @@ module Rigor
         read_first.each { |name| rbw_set << name }
       end
 
+      # ADR-38 — true when a loaded plugin declares `method_name` an
+      # additional initializer for `class_name` (or an ancestor).
+      # Reads the plugin registry off the pre-pass scope's
+      # environment; the receiver-constraint match reuses
+      # `Environment#class_ordering` (the same mechanism ADR-16
+      # Tier A's `MacroBlockSelfType` uses). The whole lookup is
+      # wrapped so any resolution failure degrades to "no match" —
+      # since the gate only ever SUPPRESSES a nil contribution, a
+      # missed match is false-positive-safe (it merely leaves the
+      # existing nil widening in place).
+      def additional_initializer?(class_name, method_name, default_scope)
+        return false if class_name.nil? || default_scope.nil?
+
+        environment = default_scope.environment
+        registry = environment&.plugin_registry
+        return false if registry.nil?
+        return false if registry.respond_to?(:empty?) && registry.empty?
+        return false unless registry.respond_to?(:additional_initializers)
+
+        registry.additional_initializers.any? do |entry|
+          entry.covers_method?(method_name) &&
+            class_matches_constraint?(class_name, entry.receiver_constraint, environment)
+        end
+      rescue StandardError
+        false
+      end
+
+      def class_matches_constraint?(class_name, constraint, environment)
+        return true if class_name == constraint
+        return false if environment.nil?
+
+        ordering = environment.class_ordering(class_name, constraint)
+        %i[equal subclass].include?(ordering)
+      rescue StandardError
+        false
+      end
+
       IVAR_WRITE_NODES = [
         Prism::InstanceVariableWriteNode,
         Prism::InstanceVariableOrWriteNode,
@@ -802,7 +853,19 @@ module Rigor
         accumulator.transform_values(&:freeze).freeze
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # Merges two `class_name => { method => kind }` tables, unioning
+      # the per-class method maps (so a seeded cross-file table and the
+      # current file's table combine instead of clobbering).
+      def deep_merge_class_methods(base, overlay)
+        return overlay if base.nil? || base.empty?
+        return base if overlay.empty?
+
+        base.merge(overlay) do |_class_name, base_methods, overlay_methods|
+          base_methods.merge(overlay_methods)
+        end
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
       def walk_methods(node, qualified_prefix, in_singleton_class, accumulator)
         return unless node.is_a?(Prism::Node)
 
@@ -836,6 +899,10 @@ module Rigor
           return
         when Prism::CallNode
           record_define_method(node, qualified_prefix, in_singleton_class, accumulator) if node.name == :define_method
+          if ATTR_MACROS.include?(node.name)
+            record_attr_methods(node, qualified_prefix, in_singleton_class,
+                                accumulator)
+          end
         end
 
         node.compact_child_nodes.each do |child|
@@ -866,7 +933,7 @@ module Rigor
           end
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
 
       # v0.1.2 — when a `Const = Data.define(*sym) do ... end`
       # / `Const = Struct.new(*sym) do ... end` constant write
@@ -1307,6 +1374,35 @@ module Rigor
         accumulator[class_name][method_name] = in_singleton_class ? :singleton : :instance
       end
 
+      # The `attr_*` accessor macros that introduce methods Rigor must
+      # treat as source-declared. Without this, a class that defines an
+      # accessor with `attr_reader :x` AND carries RBS that omits `x`
+      # (a common gap — the project ships an incomplete `sig/`) fires a
+      # false `call.undefined-method` on `obj.x`, because the
+      # undefined-method rule only suppressed `def` / `define_method` /
+      # `alias_method`-discovered methods. `attr_reader` defines
+      # readers, `attr_writer` writers (`x=`), `attr_accessor` both.
+      ATTR_MACROS = %i[attr_reader attr_writer attr_accessor].freeze
+
+      def record_attr_methods(call_node, qualified_prefix, in_singleton_class, accumulator)
+        return if qualified_prefix.empty?
+        return unless call_node.receiver.nil? # only the implicit-self macro defines on the lexical class
+        return if call_node.arguments.nil?
+
+        kind = in_singleton_class ? :singleton : :instance
+        reader = call_node.name != :attr_writer
+        writer = call_node.name != :attr_reader
+        class_name = qualified_prefix.join("::")
+        call_node.arguments.arguments.each do |arg|
+          base = literal_method_name(arg)
+          next if base.nil?
+
+          accumulator[class_name] ||= {}
+          accumulator[class_name][base] = kind if reader
+          accumulator[class_name][:"#{base}="] = kind if writer
+        end
+      end
+
       def literal_method_name(node)
         return nil unless node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
 
@@ -1386,7 +1482,7 @@ module Rigor
       # @return [Hash{Symbol => Hash}]
       #   `{ def_nodes:, def_sources:, superclasses:, includes: }`
       def discovered_def_index_for_paths(paths, buffer: nil)
-        acc = { def_nodes: {}, def_sources: {}, superclasses: {}, includes: {}, method_visibilities: {} }
+        acc = { def_nodes: {}, def_sources: {}, superclasses: {}, includes: {}, method_visibilities: {}, methods: {} }
         paths.each do |path|
           physical = buffer ? buffer.resolve(path) : path
           root = Prism.parse(File.read(physical), filepath: path).value
@@ -1396,10 +1492,30 @@ module Rigor
           # analyzer surfaces the parse error separately.
           next
         end
-        %i[def_nodes def_sources includes method_visibilities].each { |key| acc[key].each_value(&:freeze) }
+        # Cross-file method suppression is for the project's OWN
+        # accessors (attr_* / define_method / alias) — NOT for plain
+        # `def`s. A cross-file `def` on a class is exactly the ADR-17
+        # monkey-patch case the undefined-method rule deliberately
+        # surfaces (fire + def-site annotation, nudging `pre_eval:`),
+        # so dropping the `def`-declared names keeps that contract
+        # intact while still letting `attr_reader :x` in one file
+        # suppress a false undefined-method for `obj.x` in another.
+        acc[:methods] = subtract_def_methods(acc[:methods], acc[:def_nodes])
+        %i[def_nodes def_sources includes method_visibilities methods].each { |key| acc[key].each_value(&:freeze) }
         acc.transform_values(&:freeze)
       end
 
+      # Removes, per class, the method names that have a project `def`
+      # node, leaving only accessor/alias/define_method-introduced
+      # methods in the cross-file suppression table.
+      def subtract_def_methods(methods, def_nodes)
+        methods.each_with_object({}) do |(class_name, table), out|
+          defs = def_nodes[class_name] || {}
+          kept = table.reject { |method_name, _kind| defs.key?(method_name) }
+          out[class_name] = kept unless kept.empty?
+        end
+      end
+
       # Folds one file's class-keyed indexes into the cross-file
       # accumulator. `method_visibilities` (ADR-35) is collected here so
       # the override-visibility-reduced rule can read an ancestor's
@@ -1413,6 +1529,9 @@ module Rigor
         build_discovered_method_visibilities(root).each do |class_name, table|
           (acc[:method_visibilities][class_name] ||= {}).merge!(table)
         end
+        build_discovered_methods(root).each do |class_name, table|
+          (acc[:methods][class_name] ||= {}).merge!(table)
+        end
       end
 
       # Merges one file's `class → method → DefNode` map into the

data/lib/rigor/inference/statement_evaluator.rb

@@ -1371,16 +1371,21 @@ module Rigor
         end
       end
 
-      # Walks the registry and collects each plugin's
-      # `flow_contribution_for` result, swallowing per-plugin
-      # exceptions so a buggy plugin can't abort the assertion
-      # path. Mirrors `MethodDispatcher.collect_plugin_contributions`
-      # exactly — the two paths consume the same hook.
+      # ADR-37 slice 2 — gathers each plugin's post-return narrowing from
+      # BOTH the narrow `type_specifier` DSL (method-gated, wrapped as a
+      # facts-only `FlowContribution`) and the legacy
+      # `flow_contribution_for` escape valve, swallowing per-plugin
+      # exceptions so a buggy plugin can't abort the assertion path.
       def collect_plugin_contributions(registry, call_node, current_scope)
-        registry.plugins.filter_map do |plugin|
-          plugin.flow_contribution_for(call_node: call_node, scope: current_scope)
+        registry.plugins.flat_map do |plugin|
+          contributions = []
+          legacy = plugin.flow_contribution_for(call_node: call_node, scope: current_scope)
+          contributions << legacy if legacy.is_a?(Rigor::FlowContribution)
+          facts = plugin.type_specifier_facts(call_node: call_node, scope: current_scope)
+          contributions << Rigor::FlowContribution.new(post_return_facts: facts) if facts && !facts.empty?
+          contributions
         rescue StandardError
-          nil
+          []
         end
       end