rigortype 0.1.17 → 0.1.19

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n.rb

@@ -72,7 +72,13 @@ module Rigor
         }
       )
 
-      producer :locale_index do |_params|
+      # `watch:` covers every `.yml` / `.yaml` file under the locale
+      # search paths so the cache invalidates when locale files are
+      # added, removed, or edited (ADR-60 WD3). `@load_errors` is a
+      # producer-side capture: it is populated only when the block
+      # runs (a cache miss / a watched file changed), which is exactly
+      # when a malformed YAML must re-surface.
+      producer :locale_index, watch: -> { [[@locale_search_paths, "**/*.yml", "**/*.yaml"]] } do |_params|
         loader = LocaleLoader.new(
           io_boundary: io_boundary,
           search_paths: @locale_search_paths
@@ -85,21 +91,19 @@ module Rigor
       def init(_services)
         @locale_search_paths = Array(config.fetch("locale_search_paths")).map(&:to_s)
         @configured_locales = Array(config.fetch("configured_locales")).map(&:to_s)
-        @locale_index = nil
         @load_errors = []
         @load_errors_emitted = false
-        @runtime_error = nil
       end
 
       # File-level only: the once-per-run YAML load errors + the
       # runtime (cache-load) error. Per-call `t('key')` validation runs
       # over the engine-owned walk via the node_rule below (ADR-37). The
-      # locale index is lazily loaded + memoised by locale_index_or_nil.
+      # locale index is lazily loaded + memoised by `producer_value`.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = locale_index_or_nil
+        index = producer_value(:locale_index)
         diagnostics = []
         diagnostics.concat(consume_load_error_diagnostics(path)) unless @load_errors.empty?
-        diagnostics << runtime_error_diagnostic(path) if index.nil? && @runtime_error
+        diagnostics << runtime_error_diagnostic(path) if index.nil? && producer_error(:locale_index)
         diagnostics
       end
 
@@ -107,39 +111,21 @@ module Rigor
       # (the controller action), supplied by the node-rule NodeContext;
       # the controller scope comes from the file path.
       node_rule Prism::CallNode do |node, _scope, path, _fc, context|
-        index = locale_index_or_nil
+        index = producer_value(:locale_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(
-          call_node: node, locale_index: index, configured_locales: @configured_locales,
-          controller_scope: Analyzer.controller_scope_from_path(path),
-          action: context.enclosing_def&.name
-        ).map do |violation|
-          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
-        end
+        diagnostics_for(
+          Analyzer.violations_for(
+            call_node: node, locale_index: index, configured_locales: @configured_locales,
+            controller_scope: Analyzer.controller_scope_from_path(path),
+            action: context.enclosing_def&.name
+          ),
+          path: path, node: node
+        )
       end
 
       private
 
-      def locale_index_or_nil
-        return @locale_index if @locale_index
-
-        # Pass an explicit descriptor covering every `.yml` / `.yaml`
-        # file under the configured locale search paths so the cache
-        # invalidates when locale files are added, removed, or edited.
-        # Without it the auto-built descriptor depends on the
-        # `IoBoundary`'s in-process read history — empty on the
-        # first call of a fresh process — so warm cache hits would
-        # serve stale `LocaleIndex` data and hide per-call load
-        # errors (a malformed YAML in one run would not surface
-        # when a healthy cache entry from an earlier run exists).
-        descriptor = glob_descriptor(@locale_search_paths, "**/*.yml", "**/*.yaml")
-        @locale_index = cache_for(:locale_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @runtime_error = "rigor-rails-i18n: failed to load locales: #{e.class}: #{e.message}"
-        nil
-      end
-
       # The runner only invokes `diagnostics_for_file` for
       # Ruby files (`paths:` is filtered to `.rb`). YAML
       # parse errors therefore can't be anchored on the
@@ -161,9 +147,10 @@ module Rigor
       end
 
       def runtime_error_diagnostic(path)
+        error = producer_error(:locale_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @runtime_error,
+          message: "rigor-rails-i18n: failed to load locales: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes.rb

@@ -94,7 +94,12 @@ module Rigor
       #
       # Passes a `file_reader` lambda so the parser can follow
       # `draw(:admin)` → `config/routes/admin.rb` partials.
-      producer :helper_table do |_params|
+      # `watch:` (ADR-60 WD3) covers every `.rb` under `helper_paths:`
+      # so ADDING a helper file invalidates the table — the producer's
+      # own in-block reads (the routes file + the partials it follows
+      # via `draw`) are captured post-compute, but a brand-new helper
+      # file the prior run never read would otherwise read as fresh.
+      producer :helper_table, watch: -> { @helper_paths.map { |dir| [dir, "**/*.rb"] } } do |_params|
         routes_dir = "#{File.dirname(@routes_file)}/routes"
         file_reader = lambda do |name|
           io_boundary.read_file("#{routes_dir}/#{name}")
@@ -132,14 +137,6 @@ module Rigor
         HelperDiscoverer.discover(contents_per_path)
       end
 
-      def pre_read_helper_files
-        each_helper_file do |path|
-          io_boundary.read_file(path)
-        rescue Plugin::AccessDeniedError, Errno::ENOENT
-          next
-        end
-      end
-
       def each_helper_file(&)
         @helper_paths.each do |dir|
           absolute = File.expand_path(dir)
@@ -214,15 +211,11 @@ module Rigor
         return @helper_table if @helper_table_built
 
         @helper_table_built = true
-        # Read first so the IoBoundary's FileEntry digest
-        # captures into the descriptor before `cache_for`
-        # snapshots it (the same pattern documented in
-        # rigor-routes / rigor-activerecord). Helper files are
-        # pre-read for the same reason — editing a file under
-        # `app/helpers/` MUST invalidate the helper_table cache
-        # so the new custom-helper set is picked up.
-        io_boundary.read_file(@routes_file)
-        pre_read_helper_files
+        # ADR-60 WD3 record-and-validate: the producer's in-block reads
+        # (the routes file + the partials it follows) are captured into
+        # the dependency descriptor AFTER the block runs, and the
+        # producer's `watch:` covers helper-file additions — so no
+        # priming read is needed here.
         @helper_table = cache_for(:helper_table, params: {}).call
       rescue Plugin::AccessDeniedError => e
         @load_error = "rigor-rails-routes: #{e.message}"

data/plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb

@@ -147,7 +147,6 @@ module Rigor
           block_as_methods: base.block_as_methods,
           heredoc_templates: base.heredoc_templates,
           trait_registries: base.trait_registries,
-          external_files: base.external_files,
           hkt_registrations: base.hkt_registrations,
           hkt_definitions: base.hkt_definitions,
           signature_paths: base.signature_paths,

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,23 +72,31 @@ 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]
+          )
         ]
       )
 
-      def init(services)
-        @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
+      def init(_services)
+        # 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 +109,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 +146,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,
+          factory_index: read_fact(plugin_id: "factorybot", name: :factory_index),
           environment: scope.environment
         )
-        return nil if type.nil?
-
-        Rigor::FlowContribution.new(return_type: type)
       end
 
       def candidate_call?(call_node)
@@ -168,14 +182,6 @@ module Rigor
         nil
       end
 
-      def factory_index_or_nil
-        return @factory_index if @factory_index_resolved
-
-        @factory_index = @services&.fact_store&.read(plugin_id: "factorybot", name: :factory_index)
-        @factory_index_resolved = true
-        @factory_index
-      end
-
       def build_diagnostic(diag)
         Rigor::Analysis::Diagnostic.new(
           path: diag.path, line: diag.line, column: diag.column,

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers.rb

@@ -70,19 +70,14 @@ module Rigor
         ]
       )
 
-      def init(services)
-        @services = services
-        @model_index = nil
-        @model_index_resolved = false
-      end
-
       # ADR-37 — per-matcher validation over the engine-owned walk. The
       # model anchor (the enclosing `describe <Model>` const) comes from
       # the node-rule NodeContext ancestors; the diagnostic points at the
       # matcher name (message_loc). The :model_index fact (from
-      # rigor-activerecord) is read lazily; without it the rule is silent.
+      # rigor-activerecord) is read lazily via `read_fact`; without it
+      # the rule is silent.
       node_rule Prism::CallNode do |node, _scope, path, _fc, context|
-        index = model_index_or_nil
+        index = read_fact(plugin_id: "activerecord", name: :model_index)
         next [] if index.nil?
 
         Analyzer.violations_for(matcher_call: node, ancestors: context.ancestors, model_index: index).map do |violation|
@@ -90,21 +85,6 @@ module Rigor
                            message: violation.message, severity: :warning, rule: violation.rule)
         end
       end
-
-      private
-
-      # Lazily resolves `:model_index` from
-      # `rigor-activerecord`. Returns nil when the plugin
-      # isn't loaded or no index has been published; the
-      # analyzer treats nil as "no cross-check available" and
-      # falls silent.
-      def model_index_or_nil
-        return @model_index if @model_index_resolved
-
-        @model_index = @services.fact_store.read(plugin_id: "activerecord", name: :model_index)
-        @model_index_resolved = true
-        @model_index
-      end
     end
 
     Rigor::Plugin.register(ShouldaMatchers)

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

@@ -63,7 +63,7 @@ module Rigor
         }
       )
 
-      producer :worker_index do |_params|
+      producer :worker_index, watch: -> { [[@worker_search_paths, "**/*.rb"]] } do |_params|
         WorkerDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @worker_search_paths,
@@ -74,46 +74,33 @@ module Rigor
       def init(_services)
         @worker_search_paths = Array(config.fetch("worker_search_paths")).map(&:to_s)
         @worker_marker_modules = Array(config.fetch("worker_marker_modules")).map(&:to_s)
-        @worker_index = nil
-        @load_error = nil
       end
 
       # File-level only: the load-error emission. The per-call arity
       # validation runs over the engine-owned walk via the node_rule
       # below (ADR-37). The worker index is lazily loaded + memoised by
-      # worker_index_or_nil, shared by both surfaces.
+      # `producer_value`, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = worker_index_or_nil
-        return [load_error_diagnostic(path)] if index.nil? && @load_error
+        index = producer_value(:worker_index)
+        return [load_error_diagnostic(path)] if index.nil? && producer_error(:worker_index)
 
         []
       end
 
       node_rule Prism::CallNode do |node, _scope, path|
-        index = worker_index_or_nil
+        index = producer_value(:worker_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(call_node: node, worker_index: index).map do |violation|
-          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
-        end
+        diagnostics_for(Analyzer.violations_for(call_node: node, worker_index: index), path: path, node: node)
       end
 
       private
 
-      def worker_index_or_nil
-        return @worker_index if @worker_index
-
-        descriptor = glob_descriptor(@worker_search_paths, "**/*.rb")
-        @worker_index = cache_for(:worker_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @load_error = "rigor-sidekiq: failed to discover workers: #{e.class}: #{e.message}"
-        nil
-      end
-
       def load_error_diagnostic(path)
+        error = producer_error(:worker_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @load_error,
+          message: "rigor-sidekiq: failed to discover workers: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

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

@@ -74,7 +74,7 @@ module Rigor
         block_as_methods: [
           Rigor::Plugin::Macro::BlockAsMethod.new(
             receiver_constraint: "Sinatra::Base",
-            verbs: %i[get post put delete head options patch link unlink]
+            method_names: %i[get post put delete head options patch link unlink]
           )
         ]
       )

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