rigortype 0.1.18 → 0.2.0

data/lib/rigor/scope.rb

@@ -22,7 +22,8 @@ module Rigor
     attr_reader :environment, :locals, :fact_store, :self_type,
                 :ivars, :cvars, :globals,
                 :indexed_narrowings, :method_chain_narrowings,
-                :source_path, :discovery
+                :declaration_sourced,
+                :source_path, :discovery, :struct_fold_safe_locals
 
     # ADR-53 Track A — the seed-time discovery tables live on the
     # {DiscoveryIndex} the scope carries by a single reference; the
@@ -43,12 +44,20 @@ module Rigor
     def in_source_constants = @discovery.in_source_constants
     def discovered_methods = @discovery.discovered_methods
     def discovered_def_nodes = @discovery.discovered_def_nodes
+    def discovered_singleton_def_nodes = @discovery.discovered_singleton_def_nodes
     def discovered_def_sources = @discovery.discovered_def_sources
     def discovered_method_visibilities = @discovery.discovered_method_visibilities
     def discovered_superclasses = @discovery.discovered_superclasses
     def discovered_includes = @discovery.discovered_includes
     def discovered_class_sources = @discovery.discovered_class_sources
     def data_member_layouts = @discovery.data_member_layouts
+    def struct_member_layouts = @discovery.struct_member_layouts
+    # ADR-67 WD3 — call-site-inferred parameter types, keyed by
+    # `[class_name, method_name, kind]`. `build_method_entry_scope` consults
+    # this to seed an undeclared `def` parameter with the union of its
+    # resolved call-site argument types (precision-additive; an RBS-declared
+    # parameter always wins). Empty unless a collection pass seeded it.
+    def param_inferred_types = @discovery.param_inferred_types
 
     # Narrowing key for an indexed read `receiver[key]` where both
     # the receiver and the key are stable enough to address. The
@@ -86,8 +95,25 @@ module Rigor
     EMPTY_VAR_BINDINGS = {}.freeze
     EMPTY_INDEXED_NARROWINGS = {}.freeze
     EMPTY_CHAIN_NARROWINGS = {}.freeze
+    # ADR-58 WD1 — the set of variable references whose binding's `nil`
+    # constituent is *declaration-sourced*: it arrives only via the
+    # class-ivar index seed (a ctor `@x = nil` written in another method),
+    # never through a method-local write, narrowing, or parameter. Members
+    # are frozen `[kind, name]` pairs (`[:ivar, :@x]`, `[:local, :r]`).
+    # `possible-nil-receiver` consults this set and declines to fire when the
+    # receiver's optionality is purely declaration-sourced — the working
+    # program's cross-method invariant is assumed per the robustness
+    # principle. Any flow-live touch (write / narrowing) drops the mark, so
+    # the diagnostic keeps firing exactly as before on flow-observed nil.
+    EMPTY_DECLARATION_SOURCED = Set.new.freeze
+    # ADR-48 Struct slice 3 — the per-body set of local names whose struct
+    # member reads are fold-safe (provably never mutated / aliased / escaped).
+    # A static per-scope context like {#source_path}: inherited unchanged
+    # through flow transitions and ignored by `==` / `hash`.
+    EMPTY_FOLD_SAFE = Set.new.freeze
     private_constant :EMPTY_VAR_BINDINGS, :EMPTY_INDEXED_NARROWINGS,
-                     :EMPTY_CHAIN_NARROWINGS
+                     :EMPTY_CHAIN_NARROWINGS, :EMPTY_DECLARATION_SOURCED,
+                     :EMPTY_FOLD_SAFE
 
     class << self
       def empty(environment: Environment.default, source_path: nil)
@@ -106,7 +132,9 @@ module Rigor
       discovery: DiscoveryIndex::EMPTY,
       indexed_narrowings: EMPTY_INDEXED_NARROWINGS,
       method_chain_narrowings: EMPTY_CHAIN_NARROWINGS,
-      source_path: nil
+      declaration_sourced: EMPTY_DECLARATION_SOURCED,
+      source_path: nil,
+      struct_fold_safe_locals: EMPTY_FOLD_SAFE
     )
       @environment = environment
       @locals = locals
@@ -118,7 +146,9 @@ module Rigor
       @discovery = discovery
       @indexed_narrowings = indexed_narrowings
       @method_chain_narrowings = method_chain_narrowings
+      @declaration_sourced = declaration_sourced
       @source_path = source_path
+      @struct_fold_safe_locals = struct_fold_safe_locals
       freeze
     end
 
@@ -141,9 +171,15 @@ module Rigor
       # narrowing keyed on `(local, :x, :last)` no longer holds.
       new_indexed_narrowings = drop_indexed_narrowings_for(:local, name)
       new_chain_narrowings = drop_chain_narrowings_for(:local, name)
+      # ADR-58 WD1 — rebinding a local is a flow-live touch: any prior
+      # declaration-sourced mark on `name` no longer holds (the new value
+      # may carry a method-local nil). `with_declaration_sourced_local`
+      # re-establishes the mark afterward when the RHS is a pure copy of a
+      # declaration-sourced ivar read; the default is to drop it.
       rebuild(locals: new_locals, fact_store: new_fact_store,
               indexed_narrowings: new_indexed_narrowings,
-              method_chain_narrowings: new_chain_narrowings)
+              method_chain_narrowings: new_chain_narrowings,
+              declaration_sourced: drop_declaration_sourced_for(:local, name))
     end
 
     def with_fact(fact)
@@ -159,17 +195,29 @@ module Rigor
       rebuild(self_type: type)
     end
 
-    # ADR-11 per-call-site assertion gating prerequisite. The
-    # analyzer's per-file boundary stamps the current source
-    # file's path onto the seed scope; nested rebuilds carry
-    # the value through so plugin rules (`dynamic_return`'s
-    # `file_methods:` gate, sigil checks) can resolve "which
-    # file does this call site belong to?" without
+    # ADR-28 / ADR-52 slice 5a — per-file source path carried on
+    # the scope. The analyzer stamps the current file's path onto
+    # the seed scope; nested rebuilds propagate it so plugin rules
+    # (`dynamic_return`'s `file_methods:` gate, sigil checks) can
+    # resolve "which file does this call site belong to?" without
     # thread-locals.
     def with_source_path(path)
       rebuild(source_path: path)
     end
 
+    # ADR-48 Struct slice 3 — installs the per-body fold-safe-local set
+    # ({Inference::StructFoldSafety}). Set once at body entry; inherited
+    # unchanged through subsequent flow transitions.
+    def with_struct_fold_safe(locals)
+      rebuild(struct_fold_safe_locals: locals)
+    end
+
+    # True when `name`'s `Struct` member reads are fold-safe in this body
+    # (the local is provably never mutated / aliased / escaped).
+    def struct_fold_safe?(name)
+      @struct_fold_safe_locals.include?(name.to_sym)
+    end
+
     # ADR-53 Track A — swaps the whole discovery index in one transition.
     # The sole seeding path; the per-table writers it replaced are derived
     # off-`Scope` through `scope.discovery.with(table_name: table)`.
@@ -201,9 +249,46 @@ module Rigor
     def with_ivar(name, type)
       new_indexed_narrowings = drop_indexed_narrowings_for(:ivar, name)
       new_chain_narrowings = drop_chain_narrowings_for(:ivar, name)
+      # ADR-58 WD1 — a method-local ivar write or narrowing is flow-live:
+      # drop any declaration-sourced mark so subsequent reads of `@name`
+      # observe flow-live provenance and fire as before. The seed path uses
+      # `seed_declaration_sourced_ivar` to (re-)establish the mark.
       rebuild(ivars: @ivars.merge(name.to_sym => type).freeze,
               indexed_narrowings: new_indexed_narrowings,
-              method_chain_narrowings: new_chain_narrowings)
+              method_chain_narrowings: new_chain_narrowings,
+              declaration_sourced: drop_declaration_sourced_for(:ivar, name))
+    end
+
+    # ADR-58 WD1 — used by the method-entry seed to mark an ivar whose only
+    # provenance is the class-ivar index. Unlike `with_ivar` this binds the
+    # type AND records the declaration-sourced mark in one transition.
+    def seed_declaration_sourced_ivar(name, type)
+      rebuild(ivars: @ivars.merge(name.to_sym => type).freeze,
+              declaration_sourced: add_declaration_sourced(:ivar, name))
+    end
+
+    # ADR-58 WD1 — a local assignment `r = @right` whose RHS is a pure read
+    # of a declaration-sourced ivar inherits the mark, so the survey's exact
+    # rotation/traversal shape (`r = @right; r.key`) does not fire. Binds the
+    # type and stamps the local's mark in one transition (the plain
+    # `with_local` would have dropped it).
+    def with_declaration_sourced_local(name, type)
+      written = with_local(name, type)
+      written.with_local_declaration_mark(name)
+    end
+
+    # ADR-58 WD1 — re-stamp the local mark on a scope produced by
+    # `with_local` (which always drops it). Public so the sibling
+    # `with_declaration_sourced_local` can call it across the new
+    # post-write receiver without reaching into a private method.
+    def with_local_declaration_mark(name)
+      rebuild(declaration_sourced: add_declaration_sourced(:local, name))
+    end
+
+    # ADR-58 WD1 — true when `(kind, name)`'s binding optionality is purely
+    # declaration-sourced (no flow-live write/narrowing has touched it).
+    def declaration_sourced?(kind, name)
+      @declaration_sourced.include?([kind.to_sym, name.to_sym])
     end
 
     def with_cvar(name, type)
@@ -214,6 +299,23 @@ module Rigor
       rebuild(globals: @globals.merge(name.to_sym => type).freeze)
     end
 
+    # Regex match-data globals (`$~`, `$&`, `$1..$9`, the pre/post-match
+    # and last-paren back-references). Narrowed on a successful-`=~` /
+    # `case`-`when` match edge (see `Narrowing#regex_match_predicate_scopes`);
+    # any subsequent method call could run another match and rebind every
+    # one of them, so `eval_call` forgets the narrowed facts here. Always
+    # safe — only drops facts, so a subsequent read falls back to the
+    # default `String | nil`. Program-level `$GLOBAL = ...` seeds use other
+    # names and are untouched.
+    MATCH_DATA_GLOBALS = %i[$~ $& $` $' $+ $1 $2 $3 $4 $5 $6 $7 $8 $9].freeze
+    private_constant :MATCH_DATA_GLOBALS
+
+    def forget_match_globals
+      return self unless @globals.keys.any? { |k| MATCH_DATA_GLOBALS.include?(k) }
+
+      rebuild(globals: @globals.except(*MATCH_DATA_GLOBALS).freeze)
+    end
+
     # Slice 7 phase 2 — class-level ivar accumulator. Keyed by
     # the qualified class name (e.g. `"Rigor::Scope"`); the
     # value is a `Hash[Symbol, Type::t]` of every ivar that
@@ -263,8 +365,9 @@ module Rigor
     # scope (no enclosing `class` / `module` body). True at the top
     # of a file AND inside a top-level `def` body (since toplevel
     # defs leave `self_type` nil per the existing scope-construction
-    # contract, mirroring how ADR-24's `adoptable_self_call_result?`
-    # also keys on `self_type.nil?` for the same context). Used by
+    # contract — the same nil-`self_type` signal ADR-24's self-call
+    # return adoption historically keyed on before ADR-57 opened the
+    # gate unconditionally). Used by
     # `CheckRules#unresolved_toplevel_diagnostic` to gate the
     # `call.unresolved-toplevel` rule so it fires only outside
     # class / module bodies, where Rails-DSL metaprogramming
@@ -289,6 +392,22 @@ module Rigor
       node
     end
 
+    # Module-singleton call resolution (ADR-57 follow-up) — companion of
+    # {#user_def_for} for SINGLETON-side defs (`def self.x`, `def Foo.x`,
+    # `class << self` bodies, and `module_function` defs). Returns the
+    # `Prism::DefNode` for `class_name.method_name` invoked on the
+    # module/class constant itself, or nil. The `discovered_def_nodes`
+    # table is deliberately instance-side only (its ancestor walk binds
+    # `self` as `Nominal`), so singleton bodies live in a parallel table
+    # the `ScopeIndexer` populates alongside it. Records the same
+    # cross-file dependency edge as the instance path (ADR-46).
+    def singleton_def_for(class_name, method_name)
+      table = @discovery.discovered_singleton_def_nodes[class_name.to_s]
+      node = table && table[method_name.to_sym]
+      record_cross_file_method(class_name, method_name, node) if Analysis::DependencyRecorder.active?
+      node
+    end
+
     # ADR-46 slice 1 — note the cross-file dependency this resolution
     # creates: the file defining `class_name#method_name` (the consumer's
     # analysis reads its body via `infer_user_method_return`), or, when
@@ -392,6 +511,20 @@ module Rigor
       layout
     end
 
+    # ADR-48 Struct follow-up — the `{ members:, keyword_init: }` layout
+    # recorded for a `Struct.new(...)`-defined class, in the constant form
+    # (`Point = Struct.new(:x, :y)`) and the named-subclass form
+    # (`class Point < Struct.new(:x, :y)`). Consumed by
+    # {Inference::MethodDispatcher::StructFolding} so `Point.new(...)` on a
+    # `Singleton[Point]` receiver materialises a member instance. Returns nil
+    # when the class has no recorded struct layout. Mirrors
+    # {#data_member_layout}'s dependency-recording contract.
+    def struct_member_layout(class_name)
+      layout = @discovery.struct_member_layouts[class_name.to_s]
+      record_class_dependency(class_name) if layout && Analysis::DependencyRecorder.active?
+      layout
+    end
+
     # ADR-24 slice 2 — per-class/module table mapping a fully
     # qualified user class or module to the list of module
     # names it `include`s / `prepend`s, AS WRITTEN at the
@@ -564,7 +697,8 @@ module Rigor
         @cvars == other.cvars &&
         @globals == other.globals &&
         @indexed_narrowings == other.indexed_narrowings &&
-        @method_chain_narrowings == other.method_chain_narrowings
+        @method_chain_narrowings == other.method_chain_narrowings &&
+        @declaration_sourced == other.declaration_sourced
     end
     alias eql? ==
 
@@ -580,7 +714,9 @@ module Rigor
       discovery: @discovery,
       indexed_narrowings: @indexed_narrowings,
       method_chain_narrowings: @method_chain_narrowings,
-      source_path: @source_path
+      declaration_sourced: @declaration_sourced,
+      source_path: @source_path,
+      struct_fold_safe_locals: @struct_fold_safe_locals
     )
       self.class.new(
         environment: environment, locals: locals,
@@ -589,7 +725,9 @@ module Rigor
         discovery: discovery,
         indexed_narrowings: indexed_narrowings,
         method_chain_narrowings: method_chain_narrowings,
-        source_path: source_path
+        declaration_sourced: declaration_sourced,
+        source_path: source_path,
+        struct_fold_safe_locals: struct_fold_safe_locals
       )
     end
 
@@ -621,10 +759,22 @@ module Rigor
         discovery: @discovery,
         indexed_narrowings: join_bindings(@indexed_narrowings, other.indexed_narrowings),
         method_chain_narrowings: join_bindings(@method_chain_narrowings, other.method_chain_narrowings),
+        # ADR-58 WD1 — a ref is declaration-sourced after a join only when
+        # BOTH branches agree it is. If either path made the binding
+        # flow-live (a method-local nil write / failed-guard narrowing), the
+        # merge is flow-live and `possible-nil-receiver` fires as before.
+        declaration_sourced: join_declaration_sourced(other),
         source_path: source_path
       )
     end
 
+    def join_declaration_sourced(other)
+      return @declaration_sourced if @declaration_sourced.equal?(other.declaration_sourced)
+      return EMPTY_DECLARATION_SOURCED if @declaration_sourced.empty? || other.declaration_sourced.empty?
+
+      (@declaration_sourced & other.declaration_sourced).freeze
+    end
+
     def indexed_key(receiver_kind, receiver_name, key)
       IndexedKey.new(
         receiver_kind: receiver_kind.to_sym,
@@ -652,6 +802,25 @@ module Rigor
       filtered.size == @indexed_narrowings.size ? @indexed_narrowings : filtered.freeze
     end
 
+    # ADR-58 WD1 — set/clear the declaration-sourced provenance mark.
+    def add_declaration_sourced(kind, name)
+      ref = [kind.to_sym, name.to_sym]
+      return @declaration_sourced if @declaration_sourced.include?(ref)
+
+      (@declaration_sourced.dup << ref).freeze
+    end
+
+    def drop_declaration_sourced_for(kind, name)
+      return @declaration_sourced if @declaration_sourced.empty?
+
+      ref = [kind.to_sym, name.to_sym]
+      return @declaration_sourced unless @declaration_sourced.include?(ref)
+
+      dropped = @declaration_sourced.dup
+      dropped.delete(ref)
+      dropped.freeze
+    end
+
     def drop_chain_narrowings_for(receiver_kind, receiver_name)
       return @method_chain_narrowings if @method_chain_narrowings.empty?
 

data/lib/rigor/sig_gen/generator.rb

@@ -118,7 +118,15 @@ module Rigor
         @class_shells = Set.new
         defs = collect_method_definitions(parse_result.value)
         candidates_from_defs = defs.filter_map do |def_node, class_name, kind|
+          # An analyzer bug typing one def's body must cost only that
+          # def's candidate, never the whole `rigor sig-gen` run. The
+          # `check` path recovers each *file* this way
+          # (worker_session.rb); sig-gen recovers per-def so the rest of
+          # the file's candidates still emit.
+
           classify_def(path, def_node, class_name, kind, scope_index)
+        rescue StandardError
+          nil
         end
         obs_ivar_map = build_observed_ivar_map(parse_result.value)
         candidates_from_defs + collect_attr_candidates(parse_result.value, path, scope_index, obs_ivar_map)

data/lib/rigor/sig_gen/observed_call.rb

@@ -5,9 +5,9 @@ module Rigor
     # Per-call-site argument observation produced by
     # {ObservationCollector}. ADR-14 follow-up: the earlier
     # MVP shape (`Array[Type]` of positional types only)
-    # could not represent keyword arguments — every call like
-    # `MethodCatalog.new(path: ..., mutating_selectors: ...)`
-    # discarded the whole observation via `non_positional?`.
+    # could not represent keyword arguments — keyword calls
+    # like `MethodCatalog.new(path: ..., mutating_selectors: ...)`
+    # were silently skipped in that shape.
     # The new shape carries positional and keyword arg types
     # in parallel so the per-position / per-keyword unions
     # can each be reconstructed independently.

data/lib/rigor/sig_gen/writer.rb

@@ -46,6 +46,11 @@ module Rigor
       def initialize(path_mapper:, overwrite: false)
         @path_mapper = path_mapper
         @overwrite = overwrite
+        # Run-level (cross-file) namespace-kind view, populated
+        # per `#write_all` from every candidate's per-file map.
+        # Empty until then so the single-target `#write` path
+        # falls back to per-candidate kinds only.
+        @global_namespace_kinds = {}
       end
 
       # Process the full candidate list by resolving each
@@ -65,6 +70,7 @@ module Rigor
         emittable = candidates.select { |c| EMITTABLE.include?(c.classification) }
         return [] if emittable.empty?
 
+        @global_namespace_kinds = build_namespace_kinds(candidates)
         emittable.group_by { |c| @path_mapper.target_for(c.path, class_name: c.class_name) }
                  .map { |target, group| write_target(target, group) }
       end
@@ -161,13 +167,45 @@ module Rigor
       end
 
       def merged_namespace_kinds(candidates)
-        merged = {}
+        merged = @global_namespace_kinds.dup
         candidates.each do |c|
-          (c.namespace_kinds || {}).each { |k, v| merged[k] = v }
+          (c.namespace_kinds || {}).each { |k, v| apply_namespace_kind(merged, k, v) }
         end
         merged
       end
 
+      # Folds every candidate's per-file namespace-kind map
+      # into one run-level view so a `class Foo` recorded
+      # while scanning `foo.rb` governs the wrapper keyword
+      # emitted for `Foo` in a *sibling* file's target — e.g.
+      # `foo/bar.rb` declaring `class Foo::Bar`, whose compact
+      # constant path never names `Foo`, so the walker records
+      # no kind for it. Without this view that sibling target
+      # wraps the nested class in `module Foo` while `foo.rbs`
+      # declares `class Foo`; loading both raises
+      # `RBS::DuplicatedDeclarationError`, aborting the whole
+      # RBS env build.
+      def build_namespace_kinds(candidates)
+        candidates.each_with_object({}) do |candidate, acc|
+          (candidate.namespace_kinds || {}).each { |name, kind| apply_namespace_kind(acc, name, kind) }
+        end
+      end
+
+      # A `class` declaration is authoritative and MUST win
+      # over the `:module` wrapper default: a compact
+      # `class Foo::Bar` never names `Foo`, so the only signal
+      # for `Foo`'s kind is an actual `class Foo` (or
+      # `Const = Data.define(...)` shell) seen elsewhere. This
+      # guarantees the generated tree never mixes `class` /
+      # `module` for the same constant.
+      def apply_namespace_kind(map, key, kind)
+        if kind == :class
+          map[key] = :class
+        else
+          map[key] ||= :module
+        end
+      end
+
       # Tree node: { name:, children: Hash{String => node},
       # methods: Array<MethodCandidate>, shell: Boolean }.
       # `shell` flags nodes that came in via `class_shells`

data/lib/rigor/source/constant_path.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Source
+    # Flattens a Prism constant-reference node (`ConstantReadNode` /
+    # `ConstantPathNode`) to its source-qualified `"A::B::C"` string.
+    #
+    # Two nil policies for the one edge case that distinguishes the call
+    # sites — a constant path rooted in a *dynamic* base (`expr::Bar`, where
+    # the left side is a runtime expression rather than a constant):
+    #
+    # * {.qualified_name} / {.render} are LENIENT — they drop the dynamic
+    #   segment and render the trailing constant names (`expr::Bar` => "Bar").
+    #   The scope indexer and statement evaluator feed only genuine
+    #   class/module path nodes and want a best-effort name.
+    # * {.qualified_name_or_nil} is STRICT — a dynamic base anywhere in the
+    #   chain yields `nil`, so a caller that statically names constants can
+    #   treat the path as opaque rather than guessing.
+    #
+    # A leading `::` (absolute root, `::Foo`) renders as `"Foo"` under both
+    # policies. A node that is neither a `ConstantReadNode` nor a
+    # `ConstantPathNode` yields `nil` under both.
+    module ConstantPath
+      module_function
+
+      # Lenient dispatch over a constant-reference node.
+      def qualified_name(node)
+        case node
+        when Prism::ConstantReadNode then node.name.to_s
+        when Prism::ConstantPathNode then render(node)
+        end
+      end
+
+      # Lenient render of a `ConstantPathNode`; never nil for a path node.
+      def render(node)
+        prefix =
+          case node.parent
+          when Prism::ConstantReadNode then "#{node.parent.name}::"
+          when Prism::ConstantPathNode then "#{render(node.parent)}::"
+          else ""
+          end
+        "#{prefix}#{node.name}"
+      end
+
+      # Strict dispatch: a dynamic base anywhere in the path yields nil.
+      def qualified_name_or_nil(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          parent = node.parent
+          return node.name.to_s if parent.nil?
+
+          parent_name = qualified_name_or_nil(parent)
+          return nil if parent_name.nil?
+
+          "#{parent_name}::#{node.name}"
+        end
+      end
+    end
+  end
+end

data/lib/rigor/source.rb

@@ -14,3 +14,4 @@ end
 require_relative "source/node_locator"
 require_relative "source/node_walker"
 require_relative "source/literals"
+require_relative "source/constant_path"

data/lib/rigor/triage/catalogue.rb

@@ -304,26 +304,11 @@ module Rigor
         m && [m[1], m[2]]
       end
 
-      # Normalises a message receiver token to a class name.
-      # Integer / string / symbol literals fold to their class;
-      # `Foo[...]` keeps the `Array[...]` form (H4 needs it);
-      # `singleton(Foo)` and bare `Foo` fold to `Foo`.
+      # Normalises a message receiver token to a class name. The fold
+      # logic is shared with the selector axis — see
+      # {Triage.normalize_receiver}.
       def receiver_class(token)
-        t = token.strip
-        return "Integer" if t.match?(/\A-?\d+\z/)
-        return "Float"   if t.match?(/\A-?\d+\.\d+\z/)
-        return "String"  if t.start_with?('"', "'")
-        return "Symbol"  if t.start_with?(":")
-
-        singleton = t[/\Asingleton\(([\w:]+)\)\z/, 1]
-        return singleton if singleton
-        return t if t.start_with?("Array[")
-
-        nominal = t[/\A([\w:]+)\[/, 1]
-        return nominal if nominal
-        return t if t.match?(/\A[\w:]+\z/)
-
-        nil
+        Triage.normalize_receiver(token)
       end
 
       def activesupport?(receiver, method)

data/lib/rigor/triage.rb

@@ -18,7 +18,15 @@ module Rigor
     Summary = Data.define(:total, :error, :warning, :info)
     RuleCount = Data.define(:rule, :count)
     Hotspot = Data.define(:file, :count, :by_rule)
-    Report = Data.define(:summary, :distribution, :hotspots, :hints)
+    # A (receiver-class, method) dispatch target the diagnostics
+    # cluster on, built from the structured `Diagnostic#receiver_type`
+    # / `#method_name` fields — never from message-string parsing.
+    # `receiver` is nil for method-only diagnostics (a toplevel call,
+    # a `def`-side return / override finding that has no call
+    # receiver); `files` is the distinct-file count (a systemic vs.
+    # localised signal); `rules` is the per-rule breakdown.
+    Selector = Data.define(:receiver, :method_name, :count, :files, :rules)
+    Report = Data.define(:summary, :distribution, :selectors, :hotspots, :hints)
 
     module_function
 
@@ -30,6 +38,7 @@ module Rigor
       Report.new(
         summary: build_summary(diagnostics),
         distribution: build_distribution(diagnostics),
+        selectors: build_selectors(diagnostics),
         hotspots: build_hotspots(diagnostics, top),
         hints: hints ? Catalogue.recognise(diagnostics) : []
       )
@@ -57,6 +66,61 @@ module Rigor
                  .sort_by { |row| [-row.count, row.rule] }
     end
 
+    # The class/method aggregation axis (ADR-23 follow-up). Groups
+    # every diagnostic that carries a `method_name` by its
+    # `(receiver_type, method_name)` pair so a consumer can answer
+    # "which method / class concentrates the diagnostics?" with a
+    # `jq` query over the JSON instead of parsing message text.
+    # Method-only diagnostics (nil `receiver_type`) keep a null
+    # `receiver` and still group by method. The full list is
+    # returned uncapped — the JSON is the agent-facing surface; the
+    # text renderer caps its own rows.
+    def build_selectors(diagnostics)
+      diagnostics.select(&:method_name)
+                 .group_by { |d| [normalize_receiver(d.receiver_type) || d.receiver_type, d.method_name.to_s] }
+                 .map { |(receiver, method), group| selector_for(receiver, method, group) }
+                 .sort_by { |s| [-s.count, s.receiver.to_s, s.method_name] }
+    end
+
+    # Folds a receiver token — a `Diagnostic#receiver_type` display
+    # string or a message-parsed token — to the class the diagnostics
+    # should bucket under, so the selector axis does not fragment one
+    # method across every distinct literal receiver. String / integer
+    # / float / symbol literals collapse to their class; `singleton(C)`
+    # and a bare `C` fold to `C`; a generic `C[...]` keeps the
+    # `Array[String]` element form (the AR-relation heuristic keys on
+    # it). Returns nil for a token it cannot reduce to a class (a
+    # union display, an inferred shape) — the caller keeps the raw
+    # string then, never losing the row. Shared with {Catalogue}.
+    def normalize_receiver(token)
+      return nil if token.nil?
+
+      t = token.to_s.strip
+      return "Integer" if t.match?(/\A-?\d+\z/)
+      return "Float"   if t.match?(/\A-?\d+\.\d+\z/)
+      return "String"  if t.start_with?('"', "'")
+      return "Symbol"  if t.start_with?(":")
+
+      singleton = t[/\Asingleton\(([\w:]+)\)\z/, 1]
+      return singleton if singleton
+      return t if t.start_with?("Array[")
+
+      nominal = t[/\A([\w:]+)\[/, 1]
+      return nominal if nominal
+      return t if t.match?(/\A[\w:]+\z/)
+
+      nil
+    end
+
+    def selector_for(receiver, method, group)
+      rules = group.group_by { |d| rule_key(d) }
+                   .transform_values(&:size)
+                   .sort_by { |rule, count| [-count, rule] }
+                   .to_h
+      Selector.new(receiver: receiver, method_name: method, count: group.size,
+                   files: group.map(&:path).uniq.size, rules: rules)
+    end
+
     def build_hotspots(diagnostics, top)
       diagnostics.group_by(&:path)
                  .map { |path, group| hotspot_for(path, group) }
@@ -79,6 +143,10 @@ module Rigor
           "warning" => report.summary.warning, "info" => report.summary.info
         },
         "distribution" => report.distribution.map { |r| { "rule" => r.rule, "count" => r.count } },
+        "selectors" => report.selectors.map do |s|
+          { "receiver" => s.receiver, "method" => s.method_name, "count" => s.count,
+            "files" => s.files, "rules" => s.rules }
+        end,
         "hotspots" => report.hotspots.map do |h|
           { "file" => h.file, "count" => h.count, "by_rule" => h.by_rule }
         end,

data/lib/rigor/type/bound_method.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -46,17 +47,7 @@ module Rigor
         "Method"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter