rigortype 0.4.5 → 0.4.7

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

@@ -35,7 +35,8 @@ module Rigor
       #    LocalVariableReadNode. Composite receivers (`expect(foo.bar)`, `expect { ... }.to raise_error`)
       #    fall through.
       # 3. The matcher is one of the recognised forms above (`be_a` / `be_kind_of` / `be_instance_of` /
-      #    `be_an_instance_of` / `be_nil` / `eq(literal)` / `eql(literal)` / `match(/regex/)`).
+      #    `be_an_instance_of` / `be_nil` / `eq(literal)` / `eql(literal)` / `match(/regex/)`, the last a meet
+      #    with the local's members; see `regex_match_type`).
       #
       # ## Equality is the local's own method
       #
@@ -152,10 +153,7 @@ module Rigor
           when :eq, :eql
             equality_type_for_literal_arg(matcher, target_local, negative: negative, scope: scope)
           when :match
-            # `match(/regex/)` narrows x to String. `match("...")` or `match(arbitrary_object)` falls
-            # through — the broader matcher dispatch needs the receiver to be a String, but we can only
-            # assert that for a literal regex.
-            string_type_for_regex_arg(matcher)
+            regex_match_type(matcher, target_local, negative: negative, scope: scope)
           end
         end
 
@@ -293,15 +291,108 @@ module Rigor
           end
         end
 
-        def string_type_for_regex_arg(matcher)
+        # --- `match(/regex/)` (#2033) ---
+        #
+        # RSpec's `match` passes when `expected === actual`, when `actual == expected`, or when `actual` responds to
+        # `match` and `actual.match(expected)` is truthy. `Regexp#===` matches a Symbol by its name, so a Symbol
+        # passes too, and keeps being a Symbol. The positive fact is therefore a meet with the local's members, as
+        # `eq`'s is: a String or Symbol member is kept as it is, and a member of a core class that has no `match` or
+        # `to_str` and whose `==` never equals a Regexp (`nil`, `true`, `false`, the numerics) is dropped, unless the
+        # project defines one of those methods on it or a core ancestor. An `Object`, `BasicObject`, `Kernel` or
+        # `Comparable` member reads `String | Symbol` ({#module_match_member}); any other module means no fact. Any other member (a user class, `Dynamic`) may pass, and
+        # the analyzer emits no fact; so does a subject none of whose members can pass (a `nil` local stays `nil`). The negative form emits none either: a String that does not match passes
+        # `not_to match`, so nothing leaves the local.
+        REGEX_MATCH_KEPT_CLASSES = %w[String Symbol].freeze
+        REGEX_MATCH_METHODS = %i[match to_str].freeze
+        Ractor.make_shareable(REGEX_MATCH_KEPT_CLASSES)
+        Ractor.make_shareable(REGEX_MATCH_METHODS)
+        private_constant :REGEX_MATCH_KEPT_CLASSES, :REGEX_MATCH_METHODS
+
+        def regex_match_type(matcher, target_local, negative:, scope:)
+          return nil if negative || scope.nil?
+          return nil unless regex_literal_arg?(matcher)
+
+          current = scope.local(target_local)
+          return nil if current.nil?
+
+          members = current.is_a?(Rigor::Type::Union) ? current.members : [current]
+          kept = []
+          members.each do |member|
+            met = regex_match_member(member, scope)
+            return nil if met.equal?(UNDECIDED)
+
+            kept << met unless met.nil?
+          end
+          kept.empty? ? nil : Rigor::Type::Combinator.union(*kept)
+        end
+
+        def regex_literal_arg?(matcher)
           args = matcher.arguments&.arguments || []
-          return nil unless args.size == 1
+          args.size == 1 &&
+            (args.first.is_a?(Prism::RegularExpressionNode) || args.first.is_a?(Prism::InterpolatedRegularExpressionNode))
+        end
 
-          arg = args.first
-          return nil unless arg.is_a?(Prism::RegularExpressionNode) ||
-                            arg.is_a?(Prism::InterpolatedRegularExpressionNode)
+        # The member itself when it may pass, nil when it cannot, UNDECIDED when Rigor cannot tell.
+        def regex_match_member(member, scope)
+          module_member = module_match_member(member, scope)
+          return module_member unless module_member.nil?
 
-          Rigor::Type::Combinator.nominal_of("String")
+          class_name = member_class_name(member)
+          return UNDECIDED if class_name.nil?
+          return member if REGEX_MATCH_KEPT_CLASSES.include?(class_name)
+          return member if project_defines?(class_name, :==, scope)
+          return member if REGEX_MATCH_METHODS.any? { |name| project_defines_on_chain?(class_name, name, scope) }
+
+          nil
+        end
+
+        OPEN_SURFACE_CLASS_NAMES = %w[Object BasicObject].freeze
+        # The modules String's or Symbol's own ancestry includes (`Kernel`, `Comparable`), read from the running Ruby.
+        STRING_SYMBOL_MODULES = (String.ancestors + Symbol.ancestors).grep_v(Class).filter_map(&:name).uniq.freeze
+        Ractor.make_shareable(OPEN_SURFACE_CLASS_NAMES)
+        Ractor.make_shareable(STRING_SYMBOL_MODULES)
+        private_constant :OPEN_SURFACE_CLASS_NAMES, :STRING_SYMBOL_MODULES
+
+        # The meet for an `Object`, `BasicObject` or module member, or nil for any other member. Its instances may be
+        # anything, a `to_str` or `match` object included. A member that declares `match` or `to_str` itself (its
+        # 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. (Decision shared with #2256.)
+        def module_match_member(member, scope)
+          return nil unless member.is_a?(Rigor::Type::Nominal) && member.type_args.empty?
+
+          name = member.class_name
+          string_like = OPEN_SURFACE_CLASS_NAMES.include?(name) || STRING_SYMBOL_MODULES.include?(name)
+          return nil unless string_like || scope.environment&.rbs_module?(name)
+          return member if REGEX_MATCH_METHODS.any? { |method_name| declares_method?(name, method_name, scope) }
+          return UNDECIDED unless string_like
+
+          Rigor::Type::Combinator.union(Rigor::Type::Combinator.nominal_of("String"),
+                                        Rigor::Type::Combinator.nominal_of("Symbol"))
+        end
+
+        def declares_method?(name, method_name, scope)
+          project_defines_on_chain?(name, method_name, scope) ||
+            !Rigor::Reflection.instance_method_definition(name, method_name, scope: scope).nil?
+        end
+
+        # Each core class's (and `Object` / `BasicObject` / `Kernel`'s) runtime ancestor chain. The project's
+        # reopenings are looked up along it by name, since the scope's ancestry walk does not cross core classes:
+        # `class Numeric; def to_str` reaches a Float member, `module Kernel; def match` a nil one.
+        CORE_ANCESTOR_CHAINS = [*EQUALITY_CORE_CLASSES, Object, BasicObject, Kernel].to_h do |mod|
+          [mod.name, mod.ancestors.filter_map(&:name).freeze]
+        end.freeze
+        Ractor.make_shareable(CORE_ANCESTOR_CHAINS)
+        private_constant :CORE_ANCESTOR_CHAINS
+
+        # Whether the project's source defines `method_name` on `class_name` or an ancestor, core ones included: a
+        # `def`, an included module, or a `define_method`.
+        def project_defines_on_chain?(class_name, method_name, scope)
+          CORE_ANCESTOR_CHAINS.fetch(class_name, [class_name]).any? do |name|
+            !scope.user_def_through_ancestors(name, method_name).first.nil? ||
+              scope.discovered_method_through_ancestors?(name, method_name, :instance)
+          end
         end
 
         NO_LITERAL = Object.new.freeze

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

@@ -97,8 +97,11 @@ 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.
-      producer :scheduled_workers, watch: -> { [[".", *@schedule_paths]] } do |_params|
+      # 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, and an
+      # absolute path is watched under its own directory (`RootedGlob.split_file`, #2222).
+      producer :scheduled_workers,
+               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/plugins/rigor-typelizer/lib/rigor/plugin/typelizer.rb

@@ -62,7 +62,7 @@ module Rigor
           if io_boundary.directory?(File.expand_path(entry))
             [entry, "**/*.rb"]
           elsif entry.end_with?(".rb") && io_boundary.file?(File.expand_path(entry))
-            [File.dirname(entry), File.basename(entry)]
+            [File.dirname(entry), Rigor::RootedGlob.literal(File.basename(entry))]
           end
         end
       end

data/sig/rigor/analysis/baseline.rbs

@@ -66,8 +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: #1154 — an `attr_reader` over an ivar assigned in `initialize` from a parameter
-      # is skipped (untyped return); 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/file_collection.rbs

@@ -45,16 +45,15 @@ module Rigor
       # The collection a file with nothing to say contributes.
       def self.empty: (?String? path) -> FileCollection
 
-      # sig-gen gap: #1154 — `initialize` freezes the kwarg tables rather than assigning them
-      # verbatim, so sig-gen proposes the default constant's shape for each reader.
       attr_reader path: String?
-      # sig-gen gap: #1154 — `{ "Class#m" => Summary }`.
+      # sig-gen gap: #2312 — `{ "Class#m" => Summary }`, through the private `freeze_table` helper, whose parameters
+      # are undeclared.
       attr_reader summaries: Hash[String, Summary]
-      # sig-gen gap: #1154 — `{ "Class#m" => [Edge] }`, sorted and de-duplicated.
+      # sig-gen gap: #2312 — `{ "Class#m" => [Edge] }`, sorted and de-duplicated.
       attr_reader edges: Hash[String, Array[Edge]]
-      # sig-gen gap: #1154 — `{ class_name => superclass_name }`, `OPAQUE_ANCESTOR` included.
+      # sig-gen gap: #2312 — `{ class_name => superclass_name }`, `OPAQUE_ANCESTOR` included.
       attr_reader superclasses: Hash[String, String]
-      # sig-gen gap: #1154 — `{ class_name => [module_name] }`, include/prepend merged.
+      # sig-gen gap: #2312 — `{ class_name => [module_name] }`, include/prepend merged.
       attr_reader includes: Hash[String, Array[String]]
 
       def initialize: (?path: String?, ?summaries: Hash[String, Summary],

data/sig/rigor/effects/registry.rbs

@@ -32,17 +32,19 @@ module Rigor
       # an empty vocabulary (fail-open).
       def self.load_file: (untyped path) -> Registry
 
-      # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from the
-      # parameter of the same name; sig-gen proposes `untyped` for it.
       attr_reader vocabulary_version: Integer
-      # sig-gen gap: #1154 — every declared label, sorted; implied ancestors are recognised by
-      # {#known?} but not listed here.
+      # 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.
       attr_reader labels: Array[String]
       # The roots of the vocabulary — the outermost segments {#with} treats as already owned.
       # Unmarked residue: `@roots` is computed from `@known` in `initialize`, not assigned from a
-      # parameter, so #1154 does not cover it.
+      # parameter, so no parameter credit applies.
       attr_reader roots: Array[String]
-      # sig-gen gap: #1154 — one line per root, from the data file's `descriptions:`.
+      # 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]
 
       def initialize: (vocabulary_version: Integer, labels: Array[untyped],

data/sig/rigor/effects/summary.rbs

@@ -12,17 +12,18 @@ module Rigor
       # could not finish.
       def self.tainted: (String cause, ?String? detail) -> Summary
 
-      # sig-gen gap: #1154 — `initialize` normalizes the `bundles:`/`declared_bundles:` kwargs through
-      # `normalize_bundles` (join-merging per origin), so the readers do not trace to the parameters.
+      # sig-gen gap: #2312 — `initialize` normalizes the `bundles:`/`declared_bundles:` kwargs through
+      # `normalize_bundles` (join-merging per origin), a private helper whose parameters are undeclared.
       attr_reader bundles: Hash[Origin, LabelSet]
-      # sig-gen gap: #1154 — as above.
+      # sig-gen gap: #2312 — as above.
       attr_reader declared_bundles: Hash[Origin, LabelSet]
       # Unmarked residue — `proven`/`declared` are flattened from the bundle tables by `initialize`,
-      # not assigned from a parameter, so #1154 does not cover them (same shape as
+      # not assigned from a parameter at all, so no parameter credit applies (same shape as
       # `Registry#additional_initializers`).
       attr_reader declared: LabelSet
       attr_reader proven: LabelSet
-      # sig-gen gap: #1154 — `causes` are `[cause, detail]` pairs normalized in `initialize`.
+      # sig-gen gap: #2312 — `causes` are `[cause, detail]` pairs normalized by the private `normalize_causes` helper,
+      # whose parameters are undeclared.
       attr_reader causes: Array[[String, String?]]
 
       def initialize: (?bundles: Hash[Origin, LabelSet], ?declared_bundles: Hash[Origin, LabelSet],

data/sig/rigor/environment.rbs

@@ -31,8 +31,6 @@ module Rigor
     def nominal_for_name: (String | Symbol name) -> Type::Nominal?
     def singleton_for_name: (String | Symbol name) -> Type::Singleton?
     def constant_for_name: (String | Symbol name) -> Type::t?
-    # sig-gen gap: #1154 — the answer comes through `rbs_loader`, an `attr_reader` over an ivar assigned in
-    # `initialize` from a parameter, which reaches `untyped`.
     def global_for_name: (String | Symbol name, ?builtin: bool) -> Type::t?
     def class_known?: (String | Symbol name) -> bool
     def rbs_module?: (String | Symbol name) -> bool
@@ -57,7 +55,8 @@ module Rigor
       attr_reader libraries: Array[String]
       attr_reader signature_paths: Array[String | _ToPath]
       attr_reader cache_store: untyped?
-      # sig-gen gap: #160 — sig-gen emits no `attr_reader` for the loader's readers; typed as the initializer stores it.
+      # sig-gen gap: #160 — sig-gen emits no `attr_reader` for the loader's readers; typed as the initializer stores
+      # it.
       attr_reader deferred_signature_paths: Array[Pathname]
 
       def self.default: () -> RbsLoader
@@ -82,6 +81,9 @@ module Rigor
       def singleton_extended_module_names: (String | Symbol class_name) -> Array[String]
       def constant_type: (String name) -> Type::t?
       def constant_names: () -> Array[String]
+      # sig-gen gap: #2326 — the answer is `global_declarations[name.to_sym]&.first`, a lookup in the loader's memo
+      # hash `@state`, which sig-gen skips as untyped.
+      def global_type: (String | Symbol name) -> Type::t?
       def each_known_class_name: () { (String name) -> void } -> void
                               | () -> ::Enumerator[String, void]
     end