rigortype 0.1.17 → 0.1.18

data/lib/rigor/inference/method_dispatcher.rb

@@ -6,6 +6,7 @@ require_relative "../flow_contribution"
 require_relative "../flow_contribution/merger"
 require_relative "../builtins/hkt_builtins"
 require_relative "../builtins/static_return_refinements"
+require_relative "flow_tracer"
 require_relative "method_dispatcher/call_context"
 require_relative "method_dispatcher/constant_folding"
 require_relative "method_dispatcher/literal_string_folding"
@@ -73,9 +74,28 @@ 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, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def dispatch(receiver_type:, method_name:, arg_types:,
                    block_type: nil, environment: nil,
                    call_node: nil, scope: nil)
+        result = resolve(
+          receiver_type: receiver_type, method_name: method_name, arg_types: arg_types,
+          block_type: block_type, environment: environment,
+          call_node: call_node, scope: scope
+        )
+        # `rigor trace` — record the dispatch outcome (resolved type, or
+        # the fail-soft `nil` the caller widens to `Dynamic[Top]`).
+        if FlowTracer.active?
+          FlowTracer.dispatch(
+            receiver: receiver_type, method_name: method_name, args: arg_types,
+            result: result, location: call_node&.location
+          )
+        end
+        result
+      end
+
+      def resolve(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?
 
         # Build the call context once and thread it — unchanged —
@@ -217,7 +237,7 @@ module Rigor
         # introspection (`attr_reader`, `private`, ...) on
         # user classes without requiring the user to author
         # their own RBS.
-        try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type, call_node)
+        try_user_class_fallback(receiver_type, environment, call_node, context)
       end
 
       # v0.1.3 — discovered-method dispatch tier. `scope` carries
@@ -298,12 +318,12 @@ module Rigor
       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,
-      # collects the non-nil `FlowContribution` bundles, merges
-      # them through `FlowContribution::Merger`, and returns
-      # the merged `return_type` slot (or nil when no plugin
-      # contributed a return type).
+      # slice 7; ADR-52 WD3 — consults each loaded plugin's gated
+      # `dynamic_return` rules, wraps the contributed types as
+      # `FlowContribution` bundles, merges them through
+      # `FlowContribution::Merger`, and returns the merged
+      # `return_type` slot (or nil when no plugin contributed a
+      # return type).
       #
       # Plugins whose hook raises have their contribution
       # silently dropped for this call so the dispatch chain
@@ -643,23 +663,15 @@ module Rigor
         Type::Combinator.untyped
       end
 
+      # ADR-52 WD1 — the per-dispatch plugins × owns_receivers ×
+      # `class_ordering` walk moved into the compiled contribution
+      # table: the union is built once per registry (almost always
+      # empty → O(1) false) and per-class verdicts memoise per run.
       def plugin_owns_receiver?(class_name, environment)
         registry = environment&.plugin_registry
         return false if registry.nil? || registry.empty?
 
-        registry.plugins.any? do |plugin|
-          owns = plugin.manifest.owns_receivers # rigor:disable undefined-method
-          owns.any? { |owner| receiver_matches_owner?(class_name, owner, environment) }
-        end
-      end
-
-      def receiver_matches_owner?(class_name, owner, environment)
-        return true if class_name == owner
-
-        ordering = environment.class_ordering(class_name, owner)
-        %i[equal subclass].include?(ordering)
-      rescue StandardError
-        false
+        registry.contribution_index.owns_receiver?(class_name, environment)
       end
 
       def dep_source_class_name(receiver_type)
@@ -668,11 +680,11 @@ module Rigor
         end
       end
 
-      # 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.
+      # ADR-37 slice 2 / ADR-52 WD3 — gathers each plugin's return-type
+      # contribution from the gated `dynamic_return` DSL, wrapped as a
+      # return-only `FlowContribution` for the shared merger. (The legacy
+      # ungated `flow_contribution_for` escape valve was deleted once its
+      # five users migrated.)
       EMPTY_CONTRIBUTIONS = [].freeze
       private_constant :EMPTY_CONTRIBUTIONS
 
@@ -682,31 +694,48 @@ module Rigor
       #
       # 1. Only the plugins that *structurally* implement a per-call path
       #    are visited — `registry.contribution_index.for_method_dispatch`
-      #    is the registry-ordered subset overriding `flow_contribution_for`
-      #    or declaring a `dynamic_return` (GitLab: 2 of 11). Iterating the
-      #    subset in registry order, and gating each path by membership,
-      #    yields the exact same contributions in the same order as
-      #    visiting every plugin would (a skipped plugin's call returns
-      #    nil/[] anyway). The receiver-class ancestry match still happens
-      #    per dispatch inside `dynamic_return_type`.
+      #    is the registry-ordered subset declaring a `dynamic_return`.
+      #    Iterating the subset in registry order, and gating each path by
+      #    membership, yields the exact same contributions in the same
+      #    order as visiting every plugin would (a skipped plugin's call
+      #    returns nil/[] anyway). The receiver-class ancestry match still
+      #    happens per dispatch inside `dynamic_return_type`.
       # 2. Contributions accumulate lazily — allocate only when one
       #    actually appears, and share a frozen empty array otherwise. The
       #    caller treats the result as read-only (`.empty?` / `Merger.merge`).
+      # 3. ADR-52 WD1 — method-name gates compiled at registry build. The
+      #    global gate makes the common "no plugin cares about this call"
+      #    case a single Set probe; the per-plugin gate skips a plugin
+      #    whose `dynamic_return` rules are all `methods:`-gated on other
+      #    names. A pruned consultation could only have returned nil, so
+      #    contribution order and content are unchanged.
       def collect_plugin_contributions(registry, call_node, scope, receiver_type)
         index = registry.contribution_index
         relevant = index.for_method_dispatch
         return EMPTY_CONTRIBUTIONS if relevant.empty?
 
+        # `call_node` is not always a CallNode — the `&:symbol` block
+        # path dispatches with the `Prism::BlockArgumentNode` itself
+        # (`ExpressionTyper#symbol_block_return_type`). A bare `.name`
+        # here raised, and the raise was silently absorbed by
+        # `block_return_type_for`'s rescue, nil-ing the block type and
+        # flipping `select(&:p)`-style calls onto their no-block
+        # Enumerator overloads (caught by the GitLab corpus gate).
+        name = call_node.respond_to?(:name) ? call_node.name : nil
+        return EMPTY_CONTRIBUTIONS unless index.dispatch_candidate?(name)
+
+        collect_gated_contributions(index, relevant, name, call_node, scope, receiver_type)
+      end
+
+      # The post-gate walk, in registry order — the same order the
+      # ungated walk used.
+      def collect_gated_contributions(index, relevant, name, call_node, scope, receiver_type)
         result = nil
         relevant.each do |plugin|
-          if index.flow?(plugin)
-            legacy = plugin.flow_contribution_for(call_node: call_node, scope: scope)
-            (result ||= []) << legacy if legacy.is_a?(FlowContribution)
-          end
-          if index.dynamic?(plugin)
-            dynamic = plugin.dynamic_return_type(call_node: call_node, scope: scope, receiver_type: receiver_type)
-            (result ||= []) << FlowContribution.new(return_type: dynamic) if dynamic
-          end
+          next unless index.dynamic_candidate_for?(plugin, name)
+
+          dynamic = plugin.dynamic_return_type(call_node: call_node, scope: scope, receiver_type: receiver_type)
+          (result ||= []) << FlowContribution.new(return_type: dynamic) if dynamic
         rescue StandardError
           next
         end
@@ -735,13 +764,37 @@ module Rigor
       # filter the common cases first. Adding a precise tier is a
       # one-line append here rather than another link in a hand-written
       # `||` ladder.
-      PRECISE_TIERS = Ractor.make_shareable([
-        ConstantFolding, LiteralStringFolding, ShapeDispatch,
-        FileFolding, ShellwordsFolding, MathFolding, TimeFolding,
-        RegexpFolding, CGIFolding, URIFolding, SetFolding,
+      PRECISE_TIERS_HEAD = Ractor.make_shareable([
+        ConstantFolding, LiteralStringFolding, ShapeDispatch
+      ].freeze)
+      private_constant :PRECISE_TIERS_HEAD
+
+      # ADR-53 re-review follow-up (gate-by-held-key applied to the
+      # built-in tiers): the eight stdlib singleton folders are mutually
+      # exclusive — each fires only on `Singleton[<its class>]`, the
+      # first check in every `try_dispatch` — so at most one can match a
+      # given receiver and their relative trial order was never
+      # observable. Compiling them into a class-name table turns eight
+      # no-op trials per call into one Hash read, skipped entirely when
+      # the receiver is not a `Singleton` (the overwhelmingly common
+      # case). The table sits where the eight sat in the old flat list:
+      # after ShapeDispatch, before KernelDispatch.
+      STDLIB_SINGLETON_FOLDERS = Ractor.make_shareable({
+        "File" => FileFolding,
+        "Shellwords" => ShellwordsFolding,
+        "Math" => MathFolding,
+        "Time" => TimeFolding,
+        "Regexp" => RegexpFolding,
+        "CGI" => CGIFolding,
+        "URI" => URIFolding,
+        "Set" => SetFolding
+      }.freeze)
+      private_constant :STDLIB_SINGLETON_FOLDERS
+
+      PRECISE_TIERS_TAIL = Ractor.make_shareable([
         KernelDispatch, MethodFolding, BlockFolding
       ].freeze)
-      private_constant :PRECISE_TIERS
+      private_constant :PRECISE_TIERS_TAIL
 
       def dispatch_precise_tiers(context)
         # ADR-48 — Data value folding runs ahead of meta-introspection:
@@ -756,14 +809,25 @@ module Rigor
         meta_result = try_meta_introspection(context.receiver, context.method_name, context.args)
         return meta_result if meta_result
 
-        PRECISE_TIERS.each do |tier|
+        PRECISE_TIERS_HEAD.each do |tier|
+          result = tier.try_dispatch(context)
+          return result if result
+        end
+
+        receiver = context.receiver
+        if receiver.is_a?(Type::Singleton) && (folder = STDLIB_SINGLETON_FOLDERS[receiver.class_name])
+          result = folder.try_dispatch(context)
+          return result if result
+        end
+
+        PRECISE_TIERS_TAIL.each do |tier|
           result = tier.try_dispatch(context)
           return result if result
         end
         nil
       end
 
-      def try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type, call_node = nil)
+      def try_user_class_fallback(receiver_type, environment, call_node, context)
         return nil if environment.nil?
 
         fallback_receiver = user_class_fallback_receiver(receiver_type, environment)
@@ -788,14 +852,11 @@ module Rigor
         # self / `self.`-receiver calls (`puts`, `raise`, `require`)
         # keep resolving — those are the fallback's intended targets.
         RbsDispatch.try_dispatch(
-          CallContext.build(
+          context.with(
             receiver: fallback_receiver,
-            method_name: method_name,
-            args: arg_types,
-            environment: environment,
-            block_type: block_type,
             self_type_override: receiver_type,
-            public_only: explicit_non_self_receiver?(call_node)
+            public_only: explicit_non_self_receiver?(call_node),
+            call_node: nil, scope: nil
           )
         )
       end

data/lib/rigor/inference/narrowing.rb

@@ -123,6 +123,66 @@ module Rigor
         end
       end
 
+      # Three-valued truthiness certainty of a predicate's type,
+      # derived from the truthy / falsey fragments above: `:truthy`
+      # when no inhabitant is falsey (the falsey fragment is `Bot`),
+      # `:falsey` when no inhabitant is truthy, nil when both
+      # fragments are inhabited — or when the type itself is nil /
+      # `Bot` (dead code is not a certainty claim). This is the single
+      # owner of the judgment both branch-elision consumers read
+      # (`ExpressionTyper#elide_or_union` on the value side,
+      # `StatementEvaluator#live_branch_for_if` on the scope side), so
+      # the type a dead branch is elided from and the scope that stops
+      # flowing through it can never disagree.
+      def predicate_certainty(type)
+        return nil if type.nil? || type.is_a?(Type::Bot)
+
+        truthy_bot = narrow_truthy(type).is_a?(Type::Bot)
+        falsey_bot = narrow_falsey(type).is_a?(Type::Bot)
+
+        return :falsey if truthy_bot && !falsey_bot
+        return :truthy if !truthy_bot && falsey_bot
+
+        nil
+      end
+
+      # Three-valued certainty of `C === subject` for a class / module
+      # `when` pattern, derived from {.narrow_class} /
+      # {.narrow_not_class}: `:no` when no inhabitant of the subject
+      # matches, `:yes` when every inhabitant matches, `:maybe`
+      # otherwise. The value-side counterpart of the scope narrowing
+      # {.case_when_scopes} performs for the same condition shape, kept
+      # here so the branch a `case` expression's type drops and the
+      # clause whose body scope goes dead derive from one judgment.
+      def class_pattern_certainty(subject_type, class_name, environment:)
+        truthy_bot = narrow_class(subject_type, class_name, environment: environment).is_a?(Type::Bot)
+        falsey_bot = narrow_not_class(subject_type, class_name, environment: environment).is_a?(Type::Bot)
+
+        return :no if truthy_bot && !falsey_bot
+        return :yes if !truthy_bot && falsey_bot
+
+        :maybe
+      end
+
+      # Classes whose `===` is plain value equality, so a literal
+      # `when` pattern against a pinned `Constant` subject is exact in
+      # both directions. Anything else keeps custom-`===` semantics
+      # and stays `:maybe` in {.value_pattern_certainty}.
+      VALUE_EQUALITY_CLASSES = [Integer, Float, Rational, Complex, String, Symbol,
+                                TrueClass, FalseClass, NilClass].freeze
+
+      # Three-valued certainty of `<literal> === subject` for a
+      # value-equality literal pattern: exact (`:yes` / `:no`) only
+      # when the subject is itself a pinned `Constant` of a
+      # value-equality class; `:maybe` otherwise (the runtime value
+      # isn't pinned, or `===` may be user-defined).
+      def value_pattern_certainty(subject_type, pattern_value)
+        return :maybe unless subject_type.is_a?(Type::Constant)
+        return :maybe unless VALUE_EQUALITY_CLASSES.any? { |klass| subject_type.value.is_a?(klass) }
+
+        pattern_value == subject_type.value ? :yes : :no
+      end
+
       # Equality fragment of `type` against a trusted literal.
       #
       # String/Symbol/Integer equality narrows only when the current

data/lib/rigor/inference/scope_indexer.rb

@@ -68,16 +68,17 @@ module Rigor
         # collision — same-file declarations are the most
         # specific authority.
         merged_classes = default_scope.discovered_classes.merge(discovered_classes)
-        seeded_scope = default_scope
-                       .with_declared_types(declared_types)
-                       .with_discovered_classes(merged_classes)
+        seeded_scope = default_scope.with_discovery(
+          default_scope.discovery.with(declared_types: declared_types,
+                                       discovered_classes: merged_classes)
+        )
 
         # Slice 7 phase 2. Pre-pass over every class/module body
         # to collect the per-class ivar accumulator. Seeded after
         # declared_types so the rvalue typer in the pre-pass can
         # see declaration overrides.
         class_ivars = build_class_ivar_index(root, seeded_scope)
-        seeded_scope = seeded_scope.with_class_ivars(class_ivars)
+        seeded_scope = seeded_scope.with_discovery(seeded_scope.discovery.with(class_ivars: class_ivars))
 
         # Slice 7 phase 6. Same pre-pass shape for cvars (per
         # class) and globals (program-wide). Globals are also
@@ -86,9 +87,9 @@ module Rigor
         # not enter a method body) observe the precise type
         # without consulting the accumulator on every lookup.
         class_cvars = build_class_cvar_index(root, seeded_scope)
-        seeded_scope = seeded_scope.with_class_cvars(class_cvars)
+        seeded_scope = seeded_scope.with_discovery(seeded_scope.discovery.with(class_cvars: class_cvars))
         program_globals = build_program_global_index(root, seeded_scope)
-        seeded_scope = seeded_scope.with_program_globals(program_globals)
+        seeded_scope = seeded_scope.with_discovery(seeded_scope.discovery.with(program_globals: program_globals))
         program_globals.each { |name, type| seeded_scope = seeded_scope.with_global(name, type) }
 
         # Slice 7 phase 9. In-source constant value tracking.
@@ -99,7 +100,9 @@ module Rigor
         # references resolve correctly. Multiple writes to the
         # same qualified name union via `Type::Combinator.union`.
         in_source_constants = build_in_source_constants(root, seeded_scope)
-        seeded_scope = seeded_scope.with_in_source_constants(in_source_constants)
+        seeded_scope = seeded_scope.with_discovery(
+          seeded_scope.discovery.with(in_source_constants: in_source_constants)
+        )
 
         # Slice 7 phase 12. In-source method discovery. Walks
         # every class/module body for `Prism::DefNode` and
@@ -115,7 +118,7 @@ module Rigor
         discovered_methods = deep_merge_class_methods(
           default_scope.discovered_methods, build_discovered_methods(root)
         )
-        seeded_scope = seeded_scope.with_discovered_methods(discovered_methods)
+        seeded_scope = seeded_scope.with_discovery(seeded_scope.discovery.with(discovered_methods: discovered_methods))
 
         # v0.0.2 #5 + ADR-24 slice 2 — record per-instance-method
         # def nodes, the class -> superclass map, and the
@@ -179,12 +182,15 @@ module Rigor
           build_data_member_layouts(root)
         )
 
-        seeded_scope
-          .with_discovered_def_nodes(def_nodes)
-          .with_discovered_superclasses(superclasses)
-          .with_discovered_includes(includes)
-          .with_discovered_method_visibilities(method_visibilities)
-          .with_data_member_layouts(data_member_layouts)
+        seeded_scope.with_discovery(
+          seeded_scope.discovery.with(
+            discovered_def_nodes: def_nodes,
+            discovered_superclasses: superclasses,
+            discovered_includes: includes,
+            discovered_method_visibilities: method_visibilities,
+            data_member_layouts: data_member_layouts
+          )
+        )
       end
 
       # Slice 7 phase 2. Builds the class-level ivar accumulator
@@ -328,7 +334,7 @@ module Rigor
         end
       end
 
-      def walk_class_ivars(node, qualified_prefix, default_scope, accumulator, mutated_ivars,
+      def walk_class_ivars(node, qualified_prefix, default_scope, accumulator, mutated_ivars, # rubocop:disable Metrics/CyclomaticComplexity
                            read_before_write = nil, init_writes = nil)
         return unless node.is_a?(Prism::Node)
 
@@ -363,6 +369,13 @@ module Rigor
           collect_def_ivar_writes(node, qualified_prefix, default_scope, accumulator,
                                   mutated_ivars, read_before_write, init_writes)
           return
+        when Prism::CallNode
+          if init_writes && !qualified_prefix.empty? &&
+             node.block.is_a?(Prism::BlockNode) &&
+             block_initializer?(qualified_prefix.join("::"), node.name, default_scope)
+            collect_block_ivar_writes(node.block, qualified_prefix, default_scope,
+                                      accumulator, mutated_ivars, init_writes)
+          end
         end
 
         node.compact_child_nodes.each do |child|
@@ -399,6 +412,53 @@ module Rigor
         collect_read_before_write_evidence(def_node, class_name, read_before_write, init_writes, default_scope)
       end
 
+      # ADR-38 block-form: collects ivar writes from a CallNode's
+      # block body (e.g. RSpec `before { @x = … }` / `let(:x) { … }`)
+      # and folds them into `init_writes`, suppressing the
+      # read-before-write nil contribution the same way a def-form
+      # initializer does. The block body is always treated as an
+      # initializer (the caller has already verified the method name
+      # is declared as a block_method initializer), so there is no
+      # read-before-write evidence collection step here.
+      def collect_block_ivar_writes(block_node, qualified_prefix, default_scope, accumulator,
+                                    mutated_ivars, init_writes)
+        return if block_node.body.nil? || qualified_prefix.empty?
+
+        class_name = qualified_prefix.join("::")
+        self_type = Type::Combinator.nominal_of(class_name)
+        body_scope = default_scope.with_self_type(self_type)
+
+        gather_ivar_writes(block_node.body, body_scope, class_name, accumulator,
+                           EMPTY_GUARDED_IVARS, mutated_ivars)
+
+        seen_writes = Set.new
+        read_first = Set.new
+        detect_read_before_write(block_node.body, seen_writes, read_first)
+        init_set = (init_writes[class_name] ||= Set.new)
+        seen_writes.each { |name| init_set << name }
+      end
+
+      # ADR-38 block-form gate: true when a loaded plugin declares
+      # `method_name` a block-form initializer for `class_name` (or
+      # an ancestor). Mirrors `additional_initializer?` but queries
+      # `covers_block_method?` instead of `covers_method?`.
+      def block_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_block_method?(method_name) &&
+            class_matches_constraint?(class_name, entry.receiver_constraint, environment)
+        end
+      rescue StandardError
+        false
+      end
+
       # Walks the method body in AST (== execution) order
       # tracking ivar names whose first reference is a read.
       # The set is unioned into the class-wide

data/lib/rigor/inference/statement_evaluator.rb

@@ -476,31 +476,19 @@ module Rigor
       # carriers like `Nominal[Integer]` (Integer is always truthy
       # in Ruby — including 0) also collapse the dead else.
       def live_branch_for_if(node, pred_type, post_pred)
-        case predicate_certainty(pred_type)
-        when :always_truthy then eval_branch_or_nil(node.statements, post_pred)
-        when :always_falsey then eval_branch_or_nil(node.subsequent, post_pred)
+        case Narrowing.predicate_certainty(pred_type)
+        when :truthy then eval_branch_or_nil(node.statements, post_pred)
+        when :falsey then eval_branch_or_nil(node.subsequent, post_pred)
         end
       end
 
       def live_branch_for_unless(node, pred_type, post_pred)
-        case predicate_certainty(pred_type)
-        when :always_truthy then eval_branch_or_nil(node.else_clause, post_pred)
-        when :always_falsey then eval_branch_or_nil(node.statements, post_pred)
+        case Narrowing.predicate_certainty(pred_type)
+        when :truthy then eval_branch_or_nil(node.else_clause, post_pred)
+        when :falsey then eval_branch_or_nil(node.statements, post_pred)
         end
       end
 
-      def predicate_certainty(pred_type)
-        return nil if pred_type.nil? || pred_type.is_a?(Type::Bot)
-
-        truthy_bot = Narrowing.narrow_truthy(pred_type).is_a?(Type::Bot)
-        falsey_bot = Narrowing.narrow_falsey(pred_type).is_a?(Type::Bot)
-
-        return :always_falsey if truthy_bot && !falsey_bot
-        return :always_truthy if !truthy_bot && falsey_bot
-
-        nil
-      end
-
       def eval_else(node)
         return [Type::Combinator.constant_of(nil), scope] if node.statements.nil?
 
@@ -1421,10 +1409,9 @@ module Rigor
         end
       end
 
-      # 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
+      # ADR-37 slice 2 / ADR-52 WD3 — gathers each plugin's post-return
+      # narrowing from the method-gated `type_specifier` DSL, wrapped as
+      # a facts-only `FlowContribution`, swallowing per-plugin
       # exceptions so a buggy plugin can't abort the assertion path.
       EMPTY_CONTRIBUTIONS = [].freeze
       private_constant :EMPTY_CONTRIBUTIONS
@@ -1432,8 +1419,11 @@ module Rigor
       # Per-dispatch collection of plugin narrowing contributions. Mirrors
       # `MethodDispatcher#collect_plugin_contributions`: visit only the
       # registry-ordered subset of plugins that implement a per-call path
-      # (`for_statement` = overrides `flow_contribution_for` or declares a
-      # `type_specifier`), gate each path by membership, and accumulate
+      # (`for_statement` = declares a `type_specifier`), gate each path
+      # by membership AND by the ADR-52 WD1 method-name gates (every
+      # `type_specifier` rule is `methods:`-gated, so the common
+      # no-candidate case is a single Set probe; a pruned
+      # consultation could only have returned `[]`), and accumulate
       # lazily (shared frozen empty array otherwise). Same contributions in
       # the same order as visiting every plugin; the caller is read-only.
       def collect_plugin_contributions(registry, call_node, current_scope)
@@ -1441,16 +1431,21 @@ module Rigor
         relevant = index.for_statement
         return EMPTY_CONTRIBUTIONS if relevant.empty?
 
+        name = call_node.respond_to?(:name) ? call_node.name : nil
+        return EMPTY_CONTRIBUTIONS unless index.statement_candidate?(name)
+
+        collect_gated_statement_contributions(index, relevant, name, call_node, current_scope)
+      end
+
+      # The post-gate walk, in registry order — the same order the
+      # ungated walk used.
+      def collect_gated_statement_contributions(index, relevant, name, call_node, current_scope)
         result = nil
         relevant.each do |plugin|
-          if index.flow?(plugin)
-            legacy = plugin.flow_contribution_for(call_node: call_node, scope: current_scope)
-            (result ||= []) << legacy if legacy.is_a?(Rigor::FlowContribution)
-          end
-          if index.type_specifier?(plugin)
-            facts = plugin.type_specifier_facts(call_node: call_node, scope: current_scope)
-            (result ||= []) << Rigor::FlowContribution.new(post_return_facts: facts) if facts && !facts.empty?
-          end
+          next unless index.type_specifier_candidate_for?(plugin, name)
+
+          facts = plugin.type_specifier_facts(call_node: call_node, scope: current_scope)
+          (result ||= []) << Rigor::FlowContribution.new(post_return_facts: facts) if facts && !facts.empty?
         rescue StandardError
           next
         end
@@ -1834,30 +1829,18 @@ module Rigor
       # ScopeIndexer-populated declaration overrides
       # (`Prism::ConstantReadNode` for `module Foo` headers, etc.)
       # remain reachable from inside nested bodies.
-      def build_fresh_body_scope # rubocop:disable Metrics/AbcSize
-        # Single allocation instead of a 13-deep `with_*` chain — this runs
-        # per class/method body on the main walk, so the chain's dozen
-        # throwaway intermediate Scopes were a top `Scope#rebuild` source.
-        # Local-empty by design; every field is a plain inherited reference
-        # and the unset fields default to the same empty bindings the chain
-        # (from `Scope.empty`) left them at, so the scope is identical (ADR-44).
+      def build_fresh_body_scope
+        # Single allocation instead of a deep `with_*` chain — this runs
+        # per class/method body on the main walk, so the chain's throwaway
+        # intermediate Scopes were a top `Scope#rebuild` source (ADR-44).
+        # Local-empty by design; the discovery index is inherited whole by
+        # reference (ADR-53 Track A), so a table added to the index can no
+        # longer be dropped here by a missed per-field copy.
         Scope.new(
           environment: scope.environment,
           locals: {}.freeze,
           source_path: scope.source_path,
-          declared_types: scope.declared_types,
-          discovered_classes: scope.discovered_classes,
-          in_source_constants: scope.in_source_constants,
-          class_ivars: scope.class_ivars,
-          class_cvars: scope.class_cvars,
-          program_globals: scope.program_globals,
-          discovered_methods: scope.discovered_methods,
-          discovered_def_nodes: scope.discovered_def_nodes,
-          discovered_def_sources: scope.discovered_def_sources,
-          discovered_superclasses: scope.discovered_superclasses,
-          discovered_includes: scope.discovered_includes,
-          discovered_class_sources: scope.discovered_class_sources,
-          discovered_method_visibilities: scope.discovered_method_visibilities
+          discovery: scope.discovery
         )
       end