rigortype 0.4.6 → 0.4.7

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

@@ -16,7 +16,7 @@ module Rigor
       #
       # Scope:
       #
-      # - Recognises the standard six controllers (`:sessions`, `:passwords`, `:confirmations`, `:unlocks`,
+      # - Recognises the standard controllers (`:sessions`, `:passwords`, `:confirmations`, `:unlocks`,
       #   `:registrations`, `:omniauth_callbacks`).
       # - Honours `skip: [...]` to suppress controllers the project disables.
       # - Honours `path: "..."` to remap the URL path (does NOT remap the helper-name prefix — Devise uses
@@ -162,8 +162,7 @@ module Rigor
           OMNIAUTH_SUFFIXES
         end
 
-        # ADR-39 — delegates to the shared inflector (real `ActiveSupport::Inflector` when available),
-        # replacing the tiny AS-replica this module used to duplicate from `RoutesParser`.
+        # ADR-39 — delegates to the shared inflector (real `ActiveSupport::Inflector` when available).
         def singularize(word)
           Rigor::Plugin::Inflector.singularize(word)
         end

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

@@ -7,7 +7,7 @@ require "prism"
 module Rigor
   module Plugin
     class RailsRoutes < Rigor::Plugin::Base
-      # Walks `app/helpers/**/*.rb` (or any configured set of helper directories) and extracts every public
+      # Walks the configured `helper_paths:` directories (default `app/`) and extracts every public
       # module-level method name so the analyzer's `unknown-helper` rule does not false-fire on calls to
       # project-defined `*_path` / `*_url` helpers (the canonical Rails pattern: a `UrlHelper` module
       # exposing `full_asset_url`, `host_to_url`, `frontend_asset_url`, and so on).

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

@@ -409,14 +409,9 @@ module Rigor
             end
           end
 
-          # ADR-39: inflection delegates to the shared `Rigor::Plugin::Inflector`, which calls the real
-          # `ActiveSupport::Inflector` (the authority Rails itself uses to generate helper names) when
-          # available, falling back to a built-in approximation otherwise. This replaces the hand-tuned
-          # AS-replica these methods used to carry — every special case they accreted (`news` uncountable,
-          # `media`→`medium`, `databases`→`database`, `custom_css` ss-preservation,
-          # `async_refresh`→`async_refreshes`) was reverse-engineered `ActiveSupport::Inflector` behaviour,
-          # so the real inflector produces the same result for those and the correct one for the words the
-          # replica never covered.
+          # ADR-39: inflection delegates to the shared `Rigor::Plugin::Inflector`, which uses the real
+          # `ActiveSupport::Inflector` (the authority Rails uses to generate helper names) when available,
+          # and a built-in approximation otherwise.
           def singularize(word)
             Rigor::Plugin::Inflector.singularize(word)
           end
@@ -1286,7 +1281,7 @@ module Rigor
           return nil unless plural
 
           # Rails appends `_index_path` to the index helper name when the singular form of the resource
-          # matches the plural form AND the noun isn't in the canonical UNCOUNTABLE list. The collision
+          # matches the plural form (uncountable nouns included). The collision
           # would otherwise put both the index (`:id`-less) and show (`:id`-bearing) helpers under the same
           # name, and Rails disambiguates by suffixing the index form. Mastodon's `resources
           # :reblogged_by, controller: :reblogged_by_accounts, only: :index` and similar rely on this —
@@ -1432,8 +1427,6 @@ module Rigor
         end
 
         # ADR-39 — delegates to the shared inflector (real `ActiveSupport::Inflector` when available).
-        # Previously a hand-tuned AS-replica kept in sync with `Context#singularize`; both now share the
-        # one authoritative implementation.
         def singularize_word(word)
           Rigor::Plugin::Inflector.singularize(word)
         end

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

@@ -14,7 +14,7 @@ module Rigor
     # rigor-rails-routes — validates Rails route-helper calls (`users_path`, `edit_user_path(@user)`, …)
     # against the project's `config/routes.rb`.
     #
-    # Tier 1A of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
+    # Tier 1A of the [Rails plugins roadmap](../../../../../docs/design/20260508-rails-plugins-roadmap.md).
     # Statically interprets the routes DSL via Prism — no `rails` runtime dependency. Recognised v0.1.0
     # surface:
     #

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

@@ -35,7 +35,8 @@ module Rigor
     class RbsInline < Rigor::Plugin::Base
       # Synthesizer callable invoked once per project Ruby source file by `Environment.for_project` at
       # env-build time. Returns the synthesised RBS source as a String, or `nil` when the file contributes
-      # nothing (no magic comment in the default mode, empty annotation set, parse error per WD6).
+      # nothing (no annotation in the default mode, no magic comment under `require_magic_comment: true`,
+      # or a parse error per WD6).
       class Synthesizer
         # An RDoc directive comment: `#:` followed by a bare word (RDoc allows a hyphen, as in `:call-seq:`)
         # and a closing colon. RDoc predates rbs-inline by about two decades and `#:<name>:` is

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

@@ -358,7 +358,7 @@ module Rigor
         # signature, a core ancestor, or the project's source) is kept whole. `Object`, `BasicObject` and a module
         # String or Symbol includes otherwise read `String | Symbol`, as the String they most often are, so a String
         # method called after the matcher reports nothing. Any other module is UNDECIDED: a passing value may include
-        # it without being a String. (`approval-queue.d/regexp-match-open-surface-subject.md`, shared with #2256.)
+        # it without being a String. (Decision shared with #2256.)
         def module_match_member(member, scope)
           return nil unless member.is_a?(Rigor::Type::Nominal) && member.type_args.empty?
 

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

@@ -14,7 +14,7 @@ module Rigor
     # narrows `expect(x).to MATCHER` assertions downstream, and binds `let`/`subject` locals to their
     # inferred return types inside `it` bodies.
     #
-    # Tier 3A of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
+    # Tier 3A of the [Rails plugins roadmap](../../../../../docs/design/20260508-rails-plugins-roadmap.md).
     # Ships four checks:
     #
     # 1. **Duplicate `let` / `subject` declarations** in the same scope (`warning`). RSpec's runtime lets
@@ -44,7 +44,7 @@ module Rigor
     # - **No shared-context resolution.** `include_context`, `shared_context`, and `it_behaves_like` are
     #   recognised as scope-opening calls but their declarations are not pulled into the host scope.
     # - **Constant validation is not done here.** `RSpec.describe SomeClass do` does not validate
-    #   `SomeClass`; the engine's `inference.unresolved-constant` already catches that.
+    #   `SomeClass`; the engine's constant-resolution diagnostics already catch that.
     class Rspec < Rigor::Plugin::Base
       manifest(
         id: "rspec",

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

@@ -30,7 +30,7 @@ module Rigor
     # - `route_to(...)` / `redirect_to(...)` — needs the routes table from `rigor-rails-routes`
     #   (`:helper_table` cross-plugin fact). Future slice.
     # - `have_enqueued_job(JobClass)` / `have_enqueued_mail(MailerClass)` — class-existence check overlaps
-    #   with engine's `inference.unresolved-constant`; queued behind a decision on which surface owns the
+    #   with the engine's constant-resolution diagnostics; queued behind a decision on which surface owns the
     #   diagnostic.
     # - `have_received(:method)` — overlaps with engine's `call.undefined-method`; same coordination
     #   question.
@@ -44,9 +44,8 @@ module Rigor
         description: "Validates rspec-rails behavioral matchers (have_http_status floor)."
       )
 
-      # ADR-37 — the engine walks each file and hands us every CallNode; the analyzer is now pure per-node
-      # logic. The diagnostic points at the matcher name (`message_loc`), reproducing the previous
-      # `message_loc || location` positioning.
+      # ADR-37 — the engine walks each file and hands us every CallNode; the analyzer is pure per-node
+      # logic. The diagnostic points at the matcher name (`message_loc`).
       node_rule Prism::CallNode do |node, _scope, path|
         violation = HaveHttpStatusAnalyzer.violation_for(node)
         next [] unless violation

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

@@ -31,7 +31,7 @@ module Rigor
       #   have_db_index(:col)
       #
       # All look up `:col` against the model's `columns:` (the published `:model_index` fact's flat
-      # `Array<String>` per model — see `Analyzer#column_names`). Unknown columns fire `unknown-column`.
+      # name list per model — see `Analyzer#column_names`). Unknown columns fire `unknown-column`.
       #
       # ### Association matchers
       #
@@ -107,8 +107,7 @@ module Rigor
 
         # A direct matcher invocation is a `CallNode` whose `name` is in `MATCHER_TABLE` and whose first
         # argument is a `SymbolNode`. The chain shape (`should`, `expect(...).to`, `is_expected.to`) is
-        # irrelevant — we always recurse to the inner matcher, so a diagnostic fires on the matcher
-        # regardless of the surrounding chain.
+        # irrelevant: the engine visits the inner matcher call, so the diagnostic fires on it regardless.
         def matcher_invocation?(node)
           node.is_a?(Prism::CallNode) && MATCHER_TABLE.key?(node.name) && symbol_first_arg?(node)
         end
@@ -172,11 +171,10 @@ module Rigor
         end
 
         # `entry` is the published fact's per-model Hash: `{ table:, columns:, associations:, ... }`.
-        # `columns:` is a flat `Array<String>` (`Activerecord#index_to_published_hash`); `associations:` is
-        # `Array<Hash>` with String `:name`, Symbol `:kind` (`:singular` | `:collection`), `:nullable`,
-        # `:polymorphic`, and a `:target` that is a String except on polymorphic rows, where it is nil —
-        # the row shape `ModelDiscoverer#build_association_row` publishes. Only `:name` and `:kind` are
-        # read here.
+        # `columns:` is a flat list of column names (`Activerecord#index_to_published_hash`); `associations:`
+        # is a list of rows with `:name`, `:kind` (`:singular` | `:collection`), `:nullable`, `:polymorphic`,
+        # and a `:target` that is nil on polymorphic rows — the row shape `ModelDiscoverer#build_association_row`
+        # publishes. Only `:name` and `:kind` are read here.
         def column_names(entry) = entry[:columns] || []
         def association_rows(entry) = entry[:associations] || []
         def find_association(entry, name) = association_rows(entry).find { |a| a[:name] == name.to_s }

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

@@ -98,9 +98,10 @@ module Rigor
       # Cached separately from `:worker_index` because the two invalidate on different files: editing a
       # schedule changes which workers are reached without touching `app/workers` at all. The `watch:` roots
       # the glob at the working directory so that CREATING a schedule file — not just editing one — is seen. Each
-      # configured path is escaped to a literal name, so `sidekiq[1].yml` is watched as that file.
+      # configured path is escaped to a literal name, so `sidekiq[1].yml` is watched as that file, and an
+      # absolute path is watched under its own directory (`RootedGlob.split_file`, #2222).
       producer :scheduled_workers,
-               watch: -> { [[".", *@schedule_paths.map { |path| Rigor::RootedGlob.literal(path) }]] } do |_params|
+               watch: -> { @schedule_paths.map { |path| Rigor::RootedGlob.split_file(path) } } do |_params|
         ScheduleScan.new(
           io_boundary: io_boundary,
           schedule_paths: @schedule_paths

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

@@ -31,11 +31,10 @@ module Rigor
       #   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 `diagnostics_for_file` later walks the AST for
-      #   `T.absurd` calls and emits a `plugin.sorbet.absurd-reachable` warning at every 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 the `dynamic_return` rule and
-      #   `diagnostics_for_file`.
+      #   the call node in a per-plugin set. The plugin's node rule later emits a
+      #   `plugin.sorbet.absurd-reachable` warning for each recorded call node, matched by object identity.
+      #   We rely on the runner only parsing each file once per run, so the same Prism node object is seen
+      #   in both the `dynamic_return` rule and the node rule.
       module AbsurdRecognizer
         # @return true when `call_node` is `T.absurd(x)`.
         def self.absurd_call?(call_node)

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

@@ -21,7 +21,7 @@ module Rigor
       # | `T.unsafe(x)`                | return type ← `Dynamic[top]`            |
       # | `T.reveal_type(expr)`        | return type ← `inferred(expr)` (passes through) |
       # | `T.assert_type!(expr, T)`    | return type ← translated `T` + static subtype check |
-      # | `T.bind(self, T)`            | return type ← `Constant[nil]` + post_return_fact narrowing self to translated `T` |
+      # | `T.bind(self, T)`            | return type ← `Constant[nil]` + `self` narrowing fact |
       #
       # The Sorbet runtime's `T.let` / `T.cast` actually return the inner expression unchanged at runtime;
       # their job is purely to *assert* a static type. From Rigor's static perspective the simplest
@@ -36,7 +36,7 @@ module Rigor
       # `T.reveal_type` is "diagnostic-only" in Sorbet: it passes the value through unchanged at runtime
       # AND surfaces the inferred static type as a build-time message. The recogniser contributes the
       # inferred type (so chained call sites still resolve as if the `T.reveal_type` wrapper weren't
-      # there); the plugin's `diagnostics_for_file` hook surfaces the `plugin.sorbet.reveal-type` `:info`
+      # there); the plugin's node rule surfaces the `plugin.sorbet.reveal-type` `:info`
       # message for human consumption.
       #
       # `T.bind(self, T)` is recognised as block-scope self narrowing. The recogniser returns a
@@ -113,9 +113,9 @@ module Rigor
 
         # `T.assert_type!(expr, T)` shares the typed-assertion contribution shape with `T.cast` (return is
         # the asserted type), so the recogniser delegates the return-type half through
-        # `resolve_typed_assertion`. The static subtype check that distinguishes `assert_type!` from
-        # `cast` lives in the plugin's `diagnostics_for_file` hook (mirroring the absurd-recognizer
-        # pattern: record the call here, emit the diagnostic from the per-file walker).
+        # `resolve_typed_assertion`. The static subtype check that distinguishes `assert_type!` from `cast`
+        # is run by the plugin's `record_assert_type_check`, which records a mismatch for the node rule to
+        # emit (the absurd-recognizer pattern).
         def assert_type_check(call_node, scope)
           return nil if scope.nil?
 
@@ -135,8 +135,7 @@ module Rigor
         # `T.reveal_type(expr)` returns `expr` unchanged at runtime; the Sorbet-side semantics is "make
         # the inferred static type visible to the user." The contribution mirrors `T.must` minus the
         # nil-stripping: the call's return type is the inner expression's inferred type. The companion
-        # diagnostic is emitted by the plugin's `diagnostics_for_file` hook; this method handles the
-        # contribution only.
+        # diagnostic is emitted by a node rule; this method handles the contribution only.
         def resolve_reveal_type(call_node, scope)
           inner = nth_argument(call_node, 0)
           return Rigor::Type::Combinator.untyped if inner.nil? || scope.nil?

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

@@ -57,7 +57,7 @@ module Rigor
           @entries[key_for(class_name, method_name, kind)]
         end
 
-        # @return frozen mapping `{ include: [...], extend: [...] }`.
+        # @return frozen `:include` / `:extend` buckets of mixed-in module names.
         #   Returns {EMPTY_MIXINS} when no mixins were recorded.
         def mixins_for(class_name)
           @mixins[class_name] || EMPTY_MIXINS

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

@@ -22,8 +22,8 @@ module Rigor
       #
       # The parser walks the chain right-to-left, gathering whatever it recognises (`params` / `returns` /
       # `void` / `abstract` / `override` / `overridable` / `final` / `type_parameters` / `checked` /
-      # `on_failure`) into a frozen result hash stored in {MethodSignature}. Modifiers and
-      # `type_parameters` are recorded but not yet acted on.
+      # `on_failure`) into a frozen result hash stored in {MethodSignature}. Modifiers are recorded but not
+      # yet acted on; `type_parameters` is recognised and its payload discarded.
       #
       # The parser is intentionally tolerant — unknown chain nodes degrade to "the rest of the chain is
       # opaque" rather than raising. The plugin emits a diagnostic (`plugin.sorbet.parse-error`) only when

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

@@ -42,8 +42,8 @@ module Rigor
     # `IoBoundary`. The catalog is frozen after the first build and consulted by the `dynamic_return` rule
     # at every gated call site. RBI files share the catalog with project-source sigs — both produce
     # `MethodSignature` entries keyed by `(class_name, method_name, kind)`. When a key collides across
-    # files, the last-walked sig wins (ordering is platform-dependent: `Dir.glob` returns directory
-    # entries in filesystem order). Sorbet's full shim-override semantics — `sorbet/rbi/shims/` overriding
+    # files, the last-walked sig wins (`Dir.glob` results are sorted, so the walk order is stable).
+    # Sorbet's full shim-override semantics — `sorbet/rbi/shims/` overriding
     # `sorbet/rbi/gems/` — lands in a later slice once the catalog gains per-source provenance.
     #
     # The plugin emits `plugin.sorbet.parse-error` warnings for malformed sig blocks (no block / empty
@@ -79,12 +79,10 @@ module Rigor
           "rbi_paths" => { kind: :array, default: ["sorbet/rbi"] },
           "enforce_sigil" => { kind: :boolean, default: true }
         },
-        # #1097 — bundled sorbet-runtime DSL surface (`sig/sorbet.rbs`). `sig` itself reaches the
-        # class object through `extend T::Sig` (or the `< T::ImmutableStruct` / `< T::Enum`
-        # family, which carry the edge themselves), which is
-        # why `rbs_complete_extends:` — the extend-edge allow-list — carries `T::Sig` /
-        # `T::Helpers` / `T::Generic`, and `rbs_complete_ancestors:` carries the Struct/Enum family
-        # for the subclass bridge.
+        # #1097 — bundled sorbet-runtime DSL surface (`sig/sorbet.rbs`). `sig` reaches the class object
+        # through `extend T::Sig` (or the `T::Struct` / `T::Enum` family, which carry the edge themselves):
+        # `rbs_complete_extends:` is that extend-edge allow-list, and `rbs_complete_ancestors:` carries the
+        # Struct/Enum family for the subclass bridge.
         signature_paths: ["sig"],
         rbs_complete_extends: %w[T::Sig T::Helpers T::Generic],
         rbs_complete_ancestors: %w[T::Struct T::InexactStruct T::ImmutableStruct T::Enum],
@@ -122,8 +120,7 @@ module Rigor
         @configured_paths = Array(config.fetch("paths", services.configuration.paths)).map(&:to_s)
         @rbi_paths = Array(config.fetch("rbi_paths")).map(&:to_s)
         # Schema default `true` — only files marked `# typed: true` / `:strict` / `:strong` contribute
-        # their sigs. Set to `false` to record every file's sigs regardless of sigil (current behaviour
-        # pre-this-config).
+        # their sigs. Set to `false` to record every file's sigs regardless of sigil.
         @enforce_sigil = config.fetch("enforce_sigil")
         # Per-call-site assertion gating: `@sigil_by_path` (built during catalog harvest) is consulted so
         # `T.let` / `T.cast` / `T.must` / `T.bind` / `T.assert_type!` only fire in files Sorbet itself
@@ -135,20 +132,20 @@ module Rigor
         @parse_errors_by_path = {}
         @catalog_built = false
         # ADR-11 slice 6 — Prism nodes for `T.absurd` calls we observed in the `dynamic_return` rule to be
-        # *reachable* (i.e., their discriminant didn't narrow to `bot`). `diagnostics_for_file` walks the
-        # per-file AST and surfaces these as `plugin.sorbet.absurd-reachable` warnings. Hash is keyed on
-        # the Prism node's `object_id` because the runner only parses each file once per run, so identity
-        # is stable across the two plugin hooks.
+        # *reachable* (i.e., their discriminant didn't narrow to `bot`). The node rule below surfaces these
+        # as `plugin.sorbet.absurd-reachable` warnings. The Hash is keyed by node identity
+        # (`compare_by_identity`) because the runner only parses each file once per run, so identity is
+        # stable across the two plugin hooks.
         @reachable_absurd_nodes = {}.compare_by_identity
         # ADR-11 light follow-up — `T.reveal_type` calls observed in the `dynamic_return` rule, paired
         # with the display string for the inferred type at the call site. Mirrors the absurd-node
-        # compare-by-identity hash; `diagnostics_for_file` surfaces each entry as a
+        # compare-by-identity hash; the node rule below surfaces each entry as a
         # `plugin.sorbet.reveal-type` `:info` diagnostic.
         @reveal_type_calls = {}.compare_by_identity
         # T.bind / T.assert_type! priority slice 1 — `T.assert_type!` calls observed in the
         # `dynamic_return` rule whose static subtype check FAILED, paired with the inferred + asserted
-        # type display strings. Same compare-by-identity discipline. `diagnostics_for_file` walks the
-        # file AST for `T.assert_type!` calls and surfaces matching entries as
+        # type display strings. Same compare-by-identity discipline. The node rule below surfaces matching
+        # entries as
         # `plugin.sorbet.assert-type-mismatch` `:error` diagnostics.
         @assert_type_mismatches = {}.compare_by_identity
       end
@@ -245,7 +242,7 @@ module Rigor
         # analysis treats code after it as unreachable; the legacy contribution's `exceptional: :raises`
         # slot was never consumed on the dispatcher path — only `return_type` survives the merge). When
         # the discriminant *isn't* narrowed to `bot` at this scope, also records the call node so
-        # `diagnostics_for_file` can surface a `plugin.sorbet.absurd-reachable` warning.
+        # the node rule can surface a `plugin.sorbet.absurd-reachable` warning.
         if AbsurdRecognizer.absurd_call?(call_node)
           @reachable_absurd_nodes[call_node] = true unless AbsurdRecognizer.exhaustive?(call_node, scope)
           return Rigor::Type::Combinator.bot
@@ -255,7 +252,7 @@ module Rigor
         # cheaper to recognise (no catalog walk required) and they win over any cataloged signature: the
         # user explicitly asserted the type at the call site. The light follow-up extends the recogniser
         # to `T.must_because` (alias of `T.must`) and `T.reveal_type` (passes the type through; the
-        # human-facing diagnostic is recorded here for `diagnostics_for_file` to emit).
+        # human-facing diagnostic is recorded here for the node rule to emit).
         #
         # Per-call-site sigil gating: with `enforce_sigil: true` (default), assertions only fire in files
         # Sorbet itself would enforce. Files at `# typed: false` (or sigil-less, which Sorbet treats as
@@ -502,8 +499,7 @@ module Rigor
             # ADR-88 WD2 — deterministic fold order matters now that the catalog VALUE is digested into the
             # incremental fact-surface fingerprint: a duplicate `(class, method, kind)` sig's last-wins winner
             # must not vary by machine / run. `Dir.glob` sorts its results by default on Ruby 3.0+, so the fold
-            # order is already stable (the slice-1 comment's "filesystem order" caveat predates that default);
-            # this walk relies on it rather than re-sorting.
+            # order is already stable; this walk relies on it rather than re-sorting.
             Dir.glob("**/*#{ext}", base: absolute).each do |relative|
               harvest_file(canonicalize(File.join(absolute, relative)), catalog, sigil_by_path, parse_errors_by_path)
             end

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

@@ -11,9 +11,8 @@ module Rigor
     #
     #   1. **Collect pass.** Walk the file once to gather every state name declared inside a
     #      `state_machine do ... end` block (`state :draft`, `state :submitted`, ...).
-    #   2. **Validate pass.** Walk the file again, validating each `transition_to(:sym)` and `event :sym`
-    #      reference against the collected state set. Levenshtein distance ≤ 3 drives the did-you-mean
-    #      suggestions.
+    #   2. **Validate pass.** Walk the file again, validating each `transition_to(:sym)` reference against
+    #      the collected state set. `DidYouMean::SpellChecker` drives the did-you-mean suggestions.
     #
     # Useful for `aasm` / `statesman` / hand-rolled DSLs and any framework where declarations and uses
     # live in the same file. The same skeleton lifts to GraphQL types, ActiveModel validations, route

data/plugins/rigor-typelizer/lib/rigor/plugin/typelizer/serializer_discoverer.rb

@@ -10,8 +10,9 @@ require_relative "serializer_index"
 module Rigor
   module Plugin
     class Typelizer < Rigor::Plugin::Base
-      # Reads every `.rb` file under the configured typelizer dirs and the project's `paths:` through the plugin's `IoBoundary`, runs a
-      # {SerializerCollector} over each and merges the results into one {SerializerIndex}.
+      # Reads every `.rb` file under the configured typelizer dirs and the project's `paths:` through the
+      # plugin's `IoBoundary`, runs a {SerializerCollector} over each and merges the results into one
+      # {SerializerIndex}.
       class SerializerDiscoverer
         def initialize(io_boundary:, dirs:, project_paths: [])
           @io_boundary = io_boundary

data/plugins/rigor-typelizer/lib/rigor/plugin/typelizer/serializer_index.rb

@@ -3,16 +3,16 @@
 module Rigor
   module Plugin
     class Typelizer < Rigor::Plugin::Base
-      # The project's classes (every file of the project's `paths:` and the typelizer `dirs`), as the {SerializerCollector} found them. A frozen value
-      # object the `:serializer_index` producer caches.
+      # The project's classes (every file of the project's `paths:` and the typelizer `dirs`), as the
+      # {SerializerCollector} found them. A frozen value object the `:serializer_index` producer caches.
       #
       # {#roots} answers the one question, conservatively — a wrong "no" costs a missing root, a wrong "yes"
       # hides a dead class.
       class SerializerIndex
         # A class the project declares. `superclass` is the constant as written (`nil` when absent) and
         # `nesting` the `Module.nesting` chain (innermost first) its header was written under, which is where
-        # Ruby resolves that constant. `dsl` is true when its body includes or extends `Typelizer::DSL`; `in_dirs` when a file under the
-        # typelizer `dirs` declares it (only such a class is published as a root).
+        # Ruby resolves that constant. `dsl` is true when its body includes or extends `Typelizer::DSL`;
+        # `in_dirs` when a file under the typelizer `dirs` declares it (only such a class is published as a root).
         ClassEntry = Data.define(:name, :superclass, :nesting, :dsl, :in_dirs)
 
         def initialize(classes:)

data/sig/rigor/analysis/baseline.rbs

@@ -66,9 +66,6 @@ module Rigor
 
       # Always an Array of Bucket — `initialize` freezes what it is given and every caller hands it
       # Bucket instances (parse_row rows, from_diagnostics groups, `without`'s reject, or `[]`).
-      # sig-gen gap: #2321 — `initialize` assigns `buckets.freeze`, an expression derived from the
-      # parameter rather than a bare read of it, so the reader is skipped (untyped return) and the element type
-      # is hand-written.
       attr_reader buckets: Array[Bucket]
 
       # `project_root` is `Pathname.new`'d, so a `Pathname` is accepted as well as a `String`

data/sig/rigor/analysis/fact_store.rbs

@@ -3,6 +3,7 @@ module Rigor
     module CheckRules
       def self?.diagnose: (path: String, root: untyped, scope_index: Hash[untyped, Scope]) -> Array[Diagnostic]
       def self?.build_node_collectors: (String path, untyped scope_index, ?untyped root) -> Hash[Symbol, untyped]
+      # authored: returns Rigor::Analysis::CheckRules::RuleWalk::CollectorDriver, which has no RBS declaration yet (#2404); stays `untyped` until it is declared
       def self?.node_collector_driver: (Hash[Symbol, untyped] collectors) -> untyped
       def self?.shadow_verify_converged_collectors: (String path, untyped root, untyped scope_index, Hash[Symbol, untyped]? collectors) -> void
       def self?.filter_suppressed: (Array[Diagnostic] diagnostics, comments: untyped, disabled_rules: Array[String]) -> Array[Diagnostic]

data/sig/rigor/analysis/reachability/scan_cache.rbs

@@ -3,7 +3,7 @@ module Rigor
     module Reachability
       class ScanCache
         def self.open: (untyped, ?target_ruby: untyped) -> Rigor::Analysis::Reachability::ScanCache
-        def self.source_digest: () -> String
+        def self.source_digest: () -> ("unreadable" | String)
         def initialize: (path: untyped, header: untyped) -> void
         def save: () -> nil
       end

data/sig/rigor/cli/diff_command.rbs

@@ -1,4 +1,4 @@
 class Rigor::CLI::DiffCommand
   def initialize: (argv: untyped, out: untyped, err: untyped) -> void
-  def run: () -> (0 | 1 | Integer)
+  def run: () -> (0 | 1 | 64)
 end

data/sig/rigor/cli/explain_command.rbs

@@ -1,4 +1,4 @@
 class Rigor::CLI::ExplainCommand
   def initialize: (argv: untyped, out: untyped, err: untyped) -> void
-  def run: () -> (0 | Integer)
+  def run: () -> (0 | 64)
 end

data/sig/rigor/effects/registry.rbs

@@ -33,7 +33,7 @@ module Rigor
       def self.load_file: (untyped path) -> Registry
 
       attr_reader vocabulary_version: Integer
-      # sig-gen gap: #2321 — `labels:` is declared `Array[untyped]` (input `untyped`, looks deliberate; a declared
+      # sig-gen gap: #2325 — `labels:` is declared `Array[untyped]` (input `untyped`, looks deliberate; a declared
       # type is authoring intent tracked by #2325, and only then does this row generate; coercion-facing:
       # `map(&:to_s)`); every declared label, sorted. Implied ancestors are recognised by {#known?} but not listed
       # here.
@@ -42,7 +42,7 @@ module Rigor
       # Unmarked residue: `@roots` is computed from `@known` in `initialize`, not assigned from a
       # parameter, so no parameter credit applies.
       attr_reader roots: Array[String]
-      # sig-gen gap: #2321 — `descriptions:` is declared `Hash[untyped, untyped]` (input `untyped`, looks deliberate;
+      # sig-gen gap: #2325 — `descriptions:` is declared `Hash[untyped, untyped]` (input `untyped`, looks deliberate;
       # a declared type is authoring intent tracked by #2325, and only then does this row generate; coercion-facing:
       # keys and texts `to_s`'d); one line per root, from the data file's `descriptions:`.
       attr_reader descriptions: Hash[String, String]

data/sig/rigor/inference.rbs

@@ -3,7 +3,8 @@ module Rigor
     type closure_classification = :non_escaping | :escaping | :unknown
 
     class ExpressionTyper
-      def self.harvest_return_memo: () -> Hash[untyped, Array[untyped]]
+      def self.harvest_return_memo: (?Hash[untyped, Hash[untyped, untyped]]? bucket) -> Hash[untyped, Array[untyped]]
+      def self.current_return_memo: () -> Hash[untyped, Hash[untyped, untyped]]?
       def initialize: (scope: Scope, ?tracer: FallbackTracer?) -> void
       def type_of: (untyped node) -> Type::t
       def return_type_for: (untyped def_node, Type::t receiver, Array[Type::t] arg_types) -> Type::t?
@@ -172,6 +173,8 @@ module Rigor
       def self?.collect_class_decls: (untyped node, Array[String] qualified_prefix, Hash[String, Type::t] accumulator) -> void
       def self?.constant_writes_for_file: (untyped root) -> Hash[String, untyped]
       def self?.constant_literal_value: (untyped rvalue) -> Array[untyped]?
+      # authored: the `Set[String]` values are source paths by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+      # would never propose it.
       def self?.finalize_constant_writes: (Hash[String, Hash[String, untyped]] writes) -> [Hash[String, Type::Constant], Hash[String, Set[String]]]
       def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void
 

data/sig/rigor/plugin/additional_initializer.rbs

@@ -4,15 +4,10 @@ module Rigor
     # the read-before-write nil soundness gate does not widen their ivars. See
     # lib/rigor/plugin/additional_initializer.rb for the full contract.
     class AdditionalInitializer
-      # sig-gen gap: #2321 — `attr_reader` rows over ivars `initialize` assigns from expressions derived from its
-      # parameters are skipped (untyped return); the constructor validates `receiver_constraint` is a non-empty String
-      # and normalizes both lists with `map(&:to_sym)`, so the stored types are hand-written.
       attr_reader receiver_constraint: String
 
-      # sig-gen gap: #2321 — as above.
       attr_reader methods: Array[Symbol]
 
-      # sig-gen gap: #2321 — as above.
       attr_reader block_methods: Array[Symbol]
 
       # The validators accept Symbol or non-empty String elements; `initialize` normalizes to

data/sig/rigor/plugin/base.rbs

@@ -84,5 +84,6 @@ class Rigor::Plugin::Base
   def effect_ancestry: () -> Array[Rigor::Plugin::EffectAncestry]
   def io_boundary: () -> Rigor::Plugin::IoBoundary
   def cache_for: (untyped producer_id, ?params: untyped, ?descriptor: untyped) -> Proc
+  # authored: returns Rigor::Cache::Descriptor::PluginEntry, which has no RBS declaration yet (#2404); stays `untyped` until it is declared
   def plugin_entry: () -> untyped
 end

data/sig/rigor/plugin/effect_attribution.rbs

@@ -19,7 +19,7 @@ module Rigor
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), and `initialize`
       # stores the private `validate_receiver!` helper's result (#2312).
       attr_reader receiver: String
-      # sig-gen gap: #2321 — `method:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # sig-gen gap: #2325 — `method:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `String | Symbol`), stored as
       # `method.to_sym`.
       attr_reader method: Symbol
@@ -28,7 +28,7 @@ module Rigor
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `Array()` of anything
       # answering `to_s`), stored from the private `normalize_labels` helper (#2312).
       attr_reader labels: Array[String]
-      # sig-gen gap: #2321 — `narrow:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # sig-gen gap: #2325 — `narrow:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`, nil kept).
       attr_reader narrow: String?
       attr_reader discharge: bool
@@ -41,7 +41,7 @@ module Rigor
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), stored from the
       # private `validate_taint!` helper (#2312).
       attr_reader taint: String?
-      # sig-gen gap: #2321 — `callee:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # sig-gen gap: #2325 — `callee:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`, nil kept).
       attr_reader callee: String?
       # sig-gen gap: #2312 — `callee_fallbacks:` is `untyped` (input `untyped`, looks deliberate; a declared type is

data/sig/rigor/plugin/effect_edge.rbs

@@ -11,7 +11,7 @@ module Rigor
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), and `initialize`
       # stores the result of the private `validate_receiver!` helper (#2312).
       attr_reader receiver: String
-      # sig-gen gap: #2321 — `method:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # sig-gen gap: #2325 — `method:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `String | Symbol | nil`),
       # stored as `method&.to_sym`.
       attr_reader method: Symbol?

data/sig/rigor/plugin/effect_entry_points.rbs

@@ -4,15 +4,15 @@ module Rigor
     # framework entry points (ADR-103 WD6). Frozen value object; {#globs} are deduplicated and
     # sorted in `initialize`.
     class EffectEntryPoints
-      # sig-gen gap: #2321 — `initialize` declares `name:` `untyped` (input `untyped`, looks deliberate; a declared
+      # sig-gen gap: #2325 — `initialize` declares `name:` `untyped` (input `untyped`, looks deliberate; a declared
       # type is authoring intent tracked by #2325, and only then does this row generate; coercion-facing: it takes
       # anything that answers `to_s`), so no input type reaches the reader.
       attr_reader name: String
-      # sig-gen gap: #2321 — `globs:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # sig-gen gap: #2325 — `globs:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `Array(globs)`, each `to_s`),
       # deduplicated and sorted in `initialize`.
       attr_reader globs: Array[String]
-      # sig-gen gap: #2321 — `why:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # sig-gen gap: #2325 — `why:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`).
       attr_reader why: String
 

data/sig/rigor/plugin/io_boundary.rbs

@@ -4,7 +4,7 @@ class Rigor::Plugin::IoBoundary
   def file?: (untyped) -> bool
   def directory?: (untyped) -> bool
   def list_directory: (untyped) -> Array[String]
-  def list_directory_kinds: (untyped) -> Hash[String, untyped]
+  def list_directory_kinds: (untyped) -> Hash[String, Symbol]
   # Records a `:names` glob row (membership only); a caller needing a match's content `read_file`s it. A `..`
   # segment, a brace or a backslash in `pattern` raises `AccessDeniedError`.
   def glob: (untyped root, untyped pattern) -> Array[String]
@@ -15,6 +15,7 @@ class Rigor::Plugin::IoBoundary
   def refusal_summary: () -> { count: Integer, first_path: String?, nearest_root: String? }?
   def open_url: (untyped url) -> String
   # Returns a frozen `Rigor::Cache::Descriptor` (no RBS yet -> untyped).
+  # authored: returns Rigor::Cache::Descriptor, which has no RBS declaration yet (#2404); stays `untyped` until it is declared
   def cache_descriptor: () -> untyped
   def replay: (untyped descriptor) -> nil
 end