rigortype 0.1.17 → 0.1.18

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

@@ -197,45 +197,83 @@ module Rigor
         MIGRATION_PATH_PATTERNS.any? { |pattern| path_s.match?(pattern) }
       end
 
-      # v0.1.2 — return-type contribution. `Model.find(id)`
-      # narrows the call site's return type to `Nominal[Model]`,
-      # so chained calls (`User.find(1).name`) resolve through
-      # the analyzer's normal dispatch instead of the RBS-level
-      # untyped fall-back. `Model.find_by(...)` narrows to
-      # `Nominal[Model] | nil` because Rails returns nil when no
-      # row matches. `where` / `find_or_*` are intentionally
-      # deferred — they return relations, and Rigor does not yet
-      # carry an Enumerable-backed relation shape that would be
-      # more precise than the RBS envelope.
-      def flow_contribution_for(call_node:, scope:)
+      # The class-side finder / relation entry-point names
+      # `finder_return_type` recognises. Static half of the
+      # `dynamic_return` name gate; the run-time half comes from
+      # the model index (scopes, associations, columns).
+      FINDER_METHOD_NAMES = %i[find find_by! find_by where all order limit none select].freeze
+      private_constant :FINDER_METHOD_NAMES
+
+      # v0.1.2 — return-type contribution; ADR-52 slice 5b —
+      # migrated off `flow_contribution_for` onto the run-time
+      # `methods:` name gate. `Model.find(id)` narrows the call
+      # site's return type to `Nominal[Model]`, so chained calls
+      # (`User.find(1).name`) resolve through the analyzer's
+      # normal dispatch instead of the RBS-level untyped
+      # fall-back; scopes, association accessors, and column
+      # readers narrow per the paths below.
+      #
+      # WHY a method-name gate and not `receivers:` — the ADR-52
+      # "rigor-activerecord blocker": a project model not in RBS
+      # types its constant as `Dynamic[top]`, so a receiver-type
+      # gate declines exactly the calls this plugin exists for. A
+      # *name* gate never reads the receiver type; the block keeps
+      # the plugin's own AST-constant / `self_type` / `type_of`
+      # resolution, so the Dynamic-constant case still reaches it
+      # (the same shape as rigor-sorbet's catalog path). The set —
+      # the static finder names ∪ every scope, association, and
+      # column name (plus `column?` predicate forms) the model
+      # index discovered — is exactly the union of names the four
+      # resolution paths below can return a type for, so gating on
+      # it is byte-identical to the old ungated hook. It is broad
+      # (`name`, `id`, …), but membership is one Set probe and the
+      # expensive block runs only on candidate hits.
+      dynamic_return methods: -> { recognised_method_names } do |call_node, scope|
+        contribution_return_type(call_node, scope)
+      end
+
+      private
+
+      # The run-time name gate: finders ∪ scopes ∪ associations ∪
+      # column readers (+ `?` predicates). Resolved lazily on first
+      # dispatch (after `#prepare` built the index), memoised by the
+      # engine. Returns [] when discovery found nothing — the gate
+      # then declines every call, matching the old hook's
+      # `index.nil? || index.empty?` early return.
+      def recognised_method_names
+        index = model_index
+        return [] if index.nil? || index.empty?
+
+        names = FINDER_METHOD_NAMES.dup
+        index.entries.each_value do |entry|
+          names.concat(entry.scopes.map(&:to_sym))
+          names.concat(entry.association_names.map(&:to_sym))
+          entry.column_names.each do |column|
+            names << column.to_sym
+            names << :"#{column}?"
+          end
+        end
+        names
+      end
+
+      # The migrated body of the legacy `flow_contribution_for` —
+      # same resolution order, returning the bare type the
+      # `dynamic_return` contract expects.
+      def contribution_return_type(call_node, scope)
         return nil unless call_node.is_a?(Prism::CallNode)
 
         index = model_index
         return nil if index.nil? || index.empty?
 
-        return_type =
-          if call_node.receiver
-            class_call_return_type(call_node, index) ||
-              relation_call_return_type(call_node, scope, index) ||
-              instance_call_return_type(call_node, scope, index)
-          else
-            implicit_self_class_call_return_type(call_node, scope, index)
-          end
-        return nil if return_type.nil?
-
-        Rigor::FlowContribution.new(
-          return_type: return_type,
-          provenance: Rigor::FlowContribution::Provenance.new(
-            source_family: "plugin.#{manifest.id}",
-            plugin_id: manifest.id,
-            node: call_node,
-            descriptor: nil
-          )
-        )
+        if call_node.receiver
+          class_call_return_type(call_node, index) ||
+            relation_call_return_type(call_node, scope, index) ||
+            instance_call_return_type(call_node, scope, index)
+        else
+          implicit_self_class_call_return_type(call_node, scope, index)
+        end
       end
 
-      private
-
       def class_call_return_type(call_node, index)
         model_name = constant_receiver_name(call_node.receiver)
         return nil if model_name.nil?

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/analyzer.rb

@@ -12,7 +12,7 @@ module Rigor
       # attachment mapping the plugin sees.
       #
       # No `:error` diagnostics in this slice — the
-      # `flow_contribution_for` return-type narrowing carries
+      # `dynamic_return` return-type narrowing carries
       # the type-checking value; surfacing unknown attachment
       # names as errors requires a coupled receiver-class
       # narrowing pass that the integration spec doesn't yet
@@ -50,8 +50,8 @@ module Rigor
           return if attachments.nil?
 
           # Only flag when the method matches a known
-          # attachment name (the `flow_contribution_for`
-          # tier provides the narrowing; the diagnostic just
+          # attachment name (the `dynamic_return` rule
+          # provides the narrowing; the diagnostic just
           # confirms the recognition).
           attachment = attachments.find { |a| a[:name] == node.name.to_s }
           return if attachment.nil?

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

@@ -79,47 +79,41 @@ module Rigor
 
       # Return-type contribution: when the receiver is
       # `Nominal[Model]` and the method matches a discovered
-      # attachment, narrow to
+      # attachment, narrows to
       # `Nominal[ActiveStorage::Attached::One]` (singular) or
-      # `Nominal[ActiveStorage::Attached::Many]` (collection).
+      # `Nominal[ActiveStorage::Attached::Many]` (collection)
+      # via a `dynamic_return` rule keyed on the live set of
+      # model class names from the attachment index.
       # The chained call (`.attached?`, `.purge`, `.url`)
       # then resolves through ActiveStorage's RBS surface.
       # Attachment setters (`user.avatar=`) decline — they
       # take side-effecting argument types that the RBS
       # surface already covers.
-      def flow_contribution_for(call_node:, scope:)
-        return nil unless call_node.is_a?(Prism::CallNode)
-        return nil if call_node.receiver.nil?
-        return nil unless call_node.arguments.nil?
+      dynamic_return receivers: -> { attachment_index&.class_names || [] } do |call_node, scope|
+        next nil unless call_node.is_a?(Prism::CallNode)
+        next nil if call_node.receiver.nil?
+        next nil unless call_node.arguments.nil?
 
         index = attachment_index
-        return nil if index.nil? || index.empty?
+        next nil if index.nil? || index.empty?
 
         receiver_type = scope.type_of(call_node.receiver)
-        return nil unless receiver_type.is_a?(Rigor::Type::Nominal)
+        next nil unless receiver_type.is_a?(Rigor::Type::Nominal)
 
         attachments = index.attachments_for(receiver_type.class_name) ||
                       index.attachments_for("::#{receiver_type.class_name}")
-        return nil if attachments.nil?
+        next nil if attachments.nil?
 
         attachment = attachments.find { |a| a[:name] == call_node.name.to_s }
-        return nil if attachment.nil?
+        next nil if attachment.nil?
 
         target = case attachment[:kind]
                  when :singular then "ActiveStorage::Attached::One"
                  when :collection then "ActiveStorage::Attached::Many"
                  end
-        return nil if target.nil?
-
-        Rigor::FlowContribution.new(
-          return_type: Rigor::Type::Combinator.nominal_of(target),
-          provenance: Rigor::FlowContribution::Provenance.new(
-            source_family: "plugin.#{manifest.id}",
-            plugin_id: manifest.id,
-            node: call_node,
-            descriptor: nil
-          )
-        )
+        next nil if target.nil?
+
+        Rigor::Type::Combinator.nominal_of(target)
       end
 
       # @!visibility private

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext.rb

@@ -5,7 +5,7 @@ require "rigor/plugin"
 module Rigor
   module Plugin
     # ADR-25 — a pure RBS-bundle plugin. It ships NO analyzer code:
-    # no `diagnostics_for_file`, no `flow_contribution_for`. Its
+    # no `diagnostics_for_file`, no `dynamic_return`. Its
     # whole contribution is the manifest's `signature_paths: ["sig"]`,
     # which declares the bundled ActiveSupport `core_ext` RBS
     # directory. `Plugin::Loader` resolves that directory against

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_discoverer.rb

@@ -146,8 +146,7 @@ module Rigor
 
           class_pair = kwargs.elements.find do |elem|
             elem.is_a?(Prism::AssocNode) &&
-              elem.key.is_a?(Prism::SymbolNode) &&
-              elem.key.value == "class"
+              Source::Literals.symbol_named?(elem.key, "class")
           end
           return nil if class_pair.nil?
 

data/plugins/rigor-graphql/lib/rigor/plugin/graphql/type_scanner.rb

@@ -281,7 +281,7 @@ module Rigor
           return false unless kwargs.is_a?(Prism::KeywordHashNode)
 
           pair = kwargs.elements.find do |el|
-            el.is_a?(Prism::AssocNode) && el.key.is_a?(Prism::SymbolNode) && el.key.unescaped == "required"
+            el.is_a?(Prism::AssocNode) && Source::Literals.symbol_named?(el.key, "required")
           end
           return false if pair.nil?
 
@@ -364,7 +364,7 @@ module Rigor
           return true unless kwargs.is_a?(Prism::KeywordHashNode)
 
           null_pair = kwargs.elements.find do |el|
-            el.is_a?(Prism::AssocNode) && el.key.is_a?(Prism::SymbolNode) && el.key.unescaped == "null"
+            el.is_a?(Prism::AssocNode) && Source::Literals.symbol_named?(el.key, "null")
           end
           return true if null_pair.nil?
 

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/let_scope_index.rb

@@ -21,8 +21,8 @@ module Rigor
       #   { ... }` and `subject(:name) { ... }` declarations.
       #   `:subject` is the key for the implicit `subject { ... }`.
       #
-      # Pillar 2 Slice 2 — used by the plugin's
-      # `flow_contribution_for` hook to bind `let`-named
+      # Pillar 2 Slice 2 — used by the plugin's let-binding
+      # `dynamic_return` rule to bind `let`-named
       # method-shape calls inside `it` bodies to the let
       # block's inferred type.
       class LetScopeIndex
@@ -48,6 +48,16 @@ module Rigor
           @records.select { |rec| rec.contains?(line) }
         end
 
+        # ADR-52 slice 5a — every `let` / `subject` name declared
+        # anywhere in the file, across all describe scopes. Feeds the
+        # plugin's `dynamic_return file_methods:` gate: the engine only
+        # consults the rule for a call whose name appears here; the
+        # precise line-scoped resolution stays in `let_block_at`.
+        # @return [Array<Symbol>]
+        def let_names
+          @records.flat_map { |rec| rec.lets.keys }.uniq
+        end
+
         # Resolves a `let` name at the given line by walking
         # records innermost to outermost.
         # @return [Prism::BlockNode, nil]

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/matcher_analyzer.rb

@@ -9,7 +9,7 @@ module Rigor
   module Plugin
     class Rspec < Rigor::Plugin::Base
       # Pillar 2 Slice 1 — recognises `expect(x).to MATCHER`
-      # patterns at `flow_contribution_for` time and emits
+      # patterns at per-call recognition time and emits
       # `post_return_facts` that narrow the named local on the
       # post-call edge.
       #

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

@@ -72,6 +72,17 @@ module Rigor
                      "`subject { described_class.new(...) }`.",
         consumes: [
           { plugin_id: "factorybot", name: :factory_index, optional: true }
+        ],
+        additional_initializers: [
+          # ADR-38 block-form: `before { @ivar = … }`, `let(:x) { @ivar = … }`,
+          # and `subject { @ivar = … }` establish ivar state before `it` bodies
+          # run. Declaring them here suppresses the read-before-write nil
+          # widening that would otherwise appear on those ivars in `it` / `specify`
+          # sibling blocks.
+          Rigor::Plugin::AdditionalInitializer.new(
+            receiver_constraint: "RSpec::ExampleGroup",
+            block_methods: %i[before let subject]
+          )
         ]
       )
 
@@ -79,16 +90,16 @@ module Rigor
         @services = services
         @factory_index_resolved = false
         @factory_index = nil
-        # Per-path `LetScopeIndex` cache. The plugin's
-        # `flow_contribution_for` is called for every call
-        # node the dispatcher visits; building the index once
+        # Per-path `LetScopeIndex` cache. The let-binding
+        # `dynamic_return` rule (and its `file_methods:` gate)
+        # consult the index per call node; building it once
         # per file is essential for performance.
         @let_index_cache = {}
       end
 
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         # Build the let-scope index for this file while we
-        # have the parsed root in hand — `flow_contribution_for`
+        # have the parsed root in hand — the let-binding rule
         # picks it up from `@let_index_cache` keyed on path.
         @let_index_cache[path] ||= LetScopeIndex.build(root)
         Analyzer.diagnose(path: path, root: root).map { |diag| build_diagnostic(diag) }
@@ -101,23 +112,32 @@ module Rigor
         MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
 
-      # Pillar 2 Slice 2 — binds local reads in `it` / spec bodies to
-      # their `let(:name) { ... }` block's inferred return type. This is
-      # a *method-gated return type* (keyed on the let-bound name read),
-      # which the receiver-gated `dynamic_return` cannot express, so it
-      # stays on `flow_contribution_for` — the deprecated escape valve
-      # (ADR-37 slice 2 § "Outcome").
-      def flow_contribution_for(call_node:, scope:)
-        let_binding_contribution(call_node, scope)
+      # Pillar 2 Slice 2 / ADR-52 slice 5a — binds local reads in `it` /
+      # spec bodies to their `let(:name) { ... }` block's inferred return
+      # type. The name set varies per file (each spec file's
+      # `describe`/`let` structure), so the rule gates on the per-file
+      # `file_methods:` form: the engine resolves the file's let names
+      # once per analysed file and consults the block only for a listed
+      # name; the line-scoped shadowing resolution stays in the block.
+      dynamic_return file_methods: ->(path) { let_names_for(path) } do |call_node, scope|
+        let_binding_return_type(call_node, scope)
       end
 
       private
 
+      # The `file_methods:` gate set — every `let` / `subject` name the
+      # file declares anywhere. A safe over-approximation of the block's
+      # own `let_block_at` line-scoped lookup (a name read outside its
+      # describe scope passes the gate and is declined by the block).
+      def let_names_for(path)
+        let_scope_index_for(path)&.let_names || []
+      end
+
       # Pillar 2 Slice 2 — when the call node is a no-receiver
       # method call (`user`, `subject`, etc.) inside an RSpec
       # `describe` block whose lets include a matching name,
-      # return a `FlowContribution(return_type: <inferred>)`.
-      def let_binding_contribution(call_node, scope)
+      # return the let block's inferred type.
+      def let_binding_return_type(call_node, scope)
         return nil if scope.nil?
         return nil unless candidate_call?(call_node)
 
@@ -129,15 +149,12 @@ module Rigor
         return nil if block_node.nil?
 
         describe_const = index.describe_const_at(line)
-        type = LetTypeResolver.resolve(
+        LetTypeResolver.resolve(
           block_node,
           describe_const: describe_const,
           factory_index: factory_index_or_nil,
           environment: scope.environment
         )
-        return nil if type.nil?
-
-        Rigor::FlowContribution.new(return_type: type)
       end
 
       def candidate_call?(call_node)

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

@@ -28,16 +28,15 @@ module Rigor
       #
       # ## Two-phase mechanism
       #
-      # The recogniser is invoked from `flow_contribution_for`
+      # The recogniser is invoked from the plugin's `dynamic_return` rule
       # where the per-node `scope:` carries the proper narrowing
-      # context. It returns:
+      # context. The rule:
       #
-      # - A `FlowContribution` with `return_type: bot` and
-      #   `exceptional: :raises` regardless of reachability
-      #   (faithful to `T.absurd`'s runtime behaviour: it always
-      #   raises). This lets the engine's existing flow analysis
-      #   treat code after `T.absurd` as unreachable, matching
-      #   what users of Sorbet expect.
+      # - Contributes a `bot` return type regardless of
+      #   reachability (faithful to `T.absurd`'s runtime
+      #   behaviour: it always raises). This lets the engine's
+      #   existing flow analysis treat code after `T.absurd` as
+      #   unreachable, matching what users of Sorbet expect.
       # - When the branch is REACHABLE (the discriminant's type
       #   isn't `bot`), the recogniser also records the call
       #   node in a per-plugin set. The plugin's
@@ -47,7 +46,7 @@ module Rigor
       #   call_node whose object identity matches the recorded
       #   set. We rely on the runner only parsing each file
       #   once per run, so the same Prism node object is seen
-      #   in both `flow_contribution_for` and
+      #   in both the `dynamic_return` rule and
       #   `diagnostics_for_file`.
       module AbsurdRecognizer
         # @param call_node [Prism::CallNode]
@@ -82,26 +81,6 @@ module Rigor
           # diagnostic fires conservatively.
           false
         end
-
-        # The contribution every `T.absurd` call gets,
-        # regardless of static reachability — `T.absurd` raises
-        # at runtime, so its return type is `bot` and the call
-        # is exceptional. This lets the engine's flow analysis
-        # treat code after the call as unreachable (no
-        # `flow.unreachable-branch` from us; that's an engine
-        # rule that consults the same effect lattice).
-        def self.contribution(call_node, plugin_id)
-          Rigor::FlowContribution.new(
-            return_type: Rigor::Type::Combinator.bot,
-            exceptional: :raises,
-            provenance: Rigor::FlowContribution::Provenance.new(
-              source_family: "plugin.#{plugin_id}",
-              plugin_id: plugin_id,
-              node: call_node,
-              descriptor: nil
-            )
-          )
-        end
       end
     end
   end

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

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

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

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