rigortype 0.4.6 → 0.4.8

data/plugins/rigor-minitest/lib/rigor/plugin/minitest/assertion_analyzer.rb

@@ -17,8 +17,8 @@ module Rigor
       #
       #   assert_kind_of(T, x)        →  narrow x to T
       #   assert_instance_of(T, x)    →  narrow x to T
-      #   assert_nil(x)               →  narrow x to Constant<nil>
-      #   assert_equal(literal, x)    →  meet x with Constant<literal> (see "Equality is not identity")
+      #   assert_nil(x)               →  narrow x to nil
+      #   assert_equal(literal, x)    →  meet x with the literal (see "Equality is not identity")
       #   assert_match(regex, x)      →  narrow x to String
       #
       # ### (2) Minitest / Test::Unit `refute_*` / `assert_not_*` (negative) ###
@@ -26,7 +26,7 @@ module Rigor
       #   refute_kind_of(T, x)        →  narrow x AWAY from T
       #   refute_instance_of(T, x)    →  narrow x AWAY from T
       #   refute_nil(x)               →  narrow x AWAY from nil
-      #   refute_equal(literal, x)    →  negative Constant<literal> fact (the engine keeps x unchanged)
+      #   refute_equal(literal, x)    →  negative fact on the literal (the engine keeps x unchanged)
       #
       # Test::Unit's `assert_not_nil(x)` / `assert_not_equal(...)` / `assert_not_kind_of(...)` /
       # `assert_not_instance_of(...)` share the recognizer with `refute_*` (they're aliases).
@@ -35,8 +35,8 @@ module Rigor
       #
       #   _(x).must_be_kind_of(T)     →  narrow x to T
       #   _(x).must_be_instance_of(T) →  narrow x to T
-      #   _(x).must_be_nil            →  narrow x to Constant<nil>
-      #   _(x).must_equal(literal)    →  meet x with Constant<literal> (see "Equality is not identity")
+      #   _(x).must_be_nil            →  narrow x to nil
+      #   _(x).must_equal(literal)    →  meet x with the literal (see "Equality is not identity")
       #   _(x).must_match(regex)      →  narrow x to String
       #
       # The legacy bare `x.must_be_kind_of(T)` form (Minitest < 6.0 monkey-patched onto Object) is
@@ -48,7 +48,7 @@ module Rigor
       #
       #   _(x).wont_be_kind_of(T)     →  narrow x AWAY from T
       #   _(x).wont_be_nil            →  narrow x AWAY from nil
-      #   _(x).wont_equal(literal)    →  negative Constant<literal> fact (the engine keeps x unchanged)
+      #   _(x).wont_equal(literal)    →  negative fact on the literal (the engine keeps x unchanged)
       #
       # ## Equality is not identity
       #

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/policy_discoverer.rb

@@ -10,7 +10,8 @@ module Rigor
   module Plugin
     class Pundit < Rigor::Plugin::Base
       # Walks the configured policy-search paths via the plugin's `IoBoundary`, parses each `.rb` file with
-      # Prism, and collects classes whose immediate superclass is one of the configured base classes.
+      # Prism, and collects classes whose immediate superclass is one of the configured base classes and
+      # whose name ends in `Policy`.
       #
       # For each discovered policy class, the discoverer collects every instance-side `def name?` predicate
       # method. Non-predicate methods (`initialize`, `resolve`, helper methods) are ignored — Pundit's

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

@@ -192,15 +192,10 @@ module Rigor
           first.unescaped
         end
 
-        # Pulls the interpolation hash from the call's arguments. The trailing `Hash` argument (or
+        # Pulls the interpolation hash from the call's arguments. The trailing hash argument (or
         # `Prism::KeywordHashNode`) carries both reserved I18n options (`default:`, `scope:`, …) and
-        # interpolation variables. Returns:
-        #   {
-        #     :has_default     => bool,
-        #     :all_keys        => Set<Symbol>     (every assoc key in the hash),
-        #     :non_reserved    => Set<Symbol>     (keys NOT in RESERVED_OPTION_KEYS),
-        #     :hash_node       => Prism::Node (or nil)
-        #   }
+        # interpolation variables. Returns `:has_default`, `:all_keys` (every assoc key), `:non_reserved`
+        # (keys outside RESERVED_OPTION_KEYS) and `:hash_node` (nil when there is no hash argument).
         #
         # Note: a reserved option key (e.g. `count:`) can also serve as an interpolation value when the
         # locale's leaf string has `%{count}`. The analyzer therefore checks the missing-placeholder set

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

@@ -11,9 +11,8 @@ module Rigor
       # placeholder names. The actual translated values are not retained — the analyzer doesn't need them
       # and keeping them would bloat the cache slice.
       class LocaleIndex
-        # `placeholders` is a Hash: `locale_name => Set<String>`. `array_value` is true when at least one
-        # locale's leaf is an Array (used by `l(time, format:)` and similar). `value_kinds` is a Hash:
-        # `locale_name => Symbol` (`:string` / `:array` / `:hash`).
+        # `placeholders` maps each locale name to the `%{var}` placeholder names of its leaf. `value_kinds`
+        # maps each locale name to the leaf's kind (`:string` / `:array` / `:hash` / `:scalar`).
         Entry = Data.define(:dotted_key, :placeholders, :value_kinds) do
           def locales
             placeholders.keys

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

@@ -36,8 +36,8 @@ module Rigor
         end
 
         def load
-          per_key = {} # dotted_key => { locale => Set<String> }
-          per_key_kinds = {} # dotted_key => { locale => :string|:array|:hash }
+          per_key = {} # dotted_key => { locale => placeholder names }
+          per_key_kinds = {} # dotted_key => { locale => leaf kind }
           locales = Set.new
 
           locale_files.each do |path|
@@ -98,12 +98,9 @@ module Rigor
         # leaves are *not* recorded as entries themselves — only their descendants — but every leaf scalar
         # / array IS recorded.
         #
-        # `breadcrumbs` is a single mutable stack reused across the whole walk (push before recursing, pop
-        # after): for the 530-file / 14 MB Mastodon locale corpus the old
-        # `flat_map { flatten_tree(v, breadcrumbs + [k]) }` shape allocated a fresh breadcrumb Array at
-        # every node plus an intermediate result Array at every level — millions of short-lived objects and
-        # the run's top allocation site. The dotted key is still materialised once per leaf (it has to
-        # be); everything else is now allocation-free traversal.
+        # `breadcrumbs` is one mutable stack reused across the walk (push before recursing, pop after). A
+        # per-node Array allocation was the run's top allocation site on the 530-file Mastodon corpus; only
+        # the dotted key is materialised, once per leaf.
         def each_flattened(node, breadcrumbs, &)
           if node.is_a?(Hash)
             node.each do |k, v|

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

@@ -65,7 +65,7 @@ module Rigor
         # implicit `*_path` / `*_url` helper call, is shadowed by a same-file binding, or is in a
         # suppressed directory. ADR-37: the engine owns the walk; the same-file `shadowing` set is built
         # once as the node-rule file context.
-        def violations_for(call_node:, helper_table:, shadowing:, path:)
+        def violations_for(call_node:, helper_table:, shadowing:, path:, scope: nil, context: nil)
           return [] unless call_node.is_a?(Prism::CallNode) && implicit_helper_call?(call_node)
 
           name = call_node.name.to_s
@@ -88,11 +88,209 @@ module Rigor
             # Recognised custom / dynamic helper (no arity to check), or a directory where helpers aren't
             # customarily resolved.
             []
+          elsif self_resolves_method?(name, scope, context)
+            []
           else
             [unknown_helper_violation(name, helper_table)]
           end
         end
 
+        # True when `name` is already a method on the call's `self`, asked of the engine rather than a
+        # plugin-side name list: the project's discovered methods (`def`, `attr_*`, the singleton side) through
+        # the project's own ancestry, then the RBS ancestry. A truncated walk (`maybe`) declines too — a definer
+        # past the budget cannot be ruled out, and a false positive outranks a missed typo.
+        #
+        # `self` is read from the node's lexical ancestors (`NodeContext#ancestors`), because the scope a
+        # `node_rule` receives is the file's, not the call site's. {#call_site} names the enclosing class or
+        # module and the kinds `self` may be; where the kind is not decidable (a block in a class body, a
+        # `def obj.m`) both are asked, so a definer on either side declines and a typo on neither still reports.
+        def self_resolves_method?(name, scope, context)
+          return false if scope.nil? || context.nil?
+
+          site = call_site(context.ancestors)
+          return false if site.nil?
+          # An owner no constant spelling names (`class foo::Bar`) cannot be asked about.
+          return true if site.names.empty?
+          # A module is mixed into classes that cannot be seen from where it is defined (a controller concern).
+          return true if site.module_owner && FRAMEWORK_METHODS.key?(name)
+
+          site.names.product(site.kinds).any? { |class_name, kind| resolves_on?(class_name, name, kind, scope) }
+        end
+
+        def resolves_on?(class_name, name, kind, scope)
+          return true unless Rigor::Reflection.project_method_defined(class_name, name, kind: kind, source: :either,
+                                                                                        scope: scope).no?
+          return true unless Rigor::Reflection.rbs_method_defined(class_name, name, kind: kind, scope: scope).no?
+
+          bases = FRAMEWORK_METHODS[name]
+          !bases.nil? && !Rigor::Reflection.ancestry_reaches(class_name, bases, kind: kind, scope: scope).no?
+        end
+
+        # Rails' own `*_path` / `*_url` methods on a controller or mailer, read from the Rails source (rails/rails
+        # main, 1105756f42), each with the framework classes a project class names directly as its superclass. A
+        # project without that framework's RBS cannot see these through the ancestry, so a class whose ancestry
+        # reaches one of the listed bases declines for that name; a module declines for every name, being mixed
+        # into classes that cannot be seen.
+        #
+        # - `controller_path`: AbstractController::Base, actionpack/lib/abstract_controller/base.rb:157 (instance),
+        #   :117 (class); every framework base below inherits it (metal.rb:185, base.rb:206, api.rb:91,
+        #   actionmailer/lib/action_mailer/base.rb:479).
+        # - `append_view_path` / `prepend_view_path`: `ActionView::ViewPaths` (actionview/lib/action_view/
+        #   view_paths.rb:113, :124 instance, :46, :57 class), which `AbstractController::Rendering` includes
+        #   (abstract_controller/rendering.rb:18); `ActionController::Base` (base.rb:270), `::API` (api.rb:115) and
+        #   `ActionMailer::Base` (action_mailer/base.rb:489) include that.
+        # - `helpers_path`: a class attribute of `ActionController::Helpers` (metal/helpers.rb:68), included by
+        #   `ActionController::Base` (base.rb:273).
+        # - `edit_` / `new_` `polymorphic_path` / `polymorphic_url`: actionpack/lib/action_dispatch/routing/
+        #   polymorphic_routes.rb:163-166, through `UrlFor` in `ActionController::Base` (base.rb:274) and `::API`
+        #   (api.rb:117), and in `ActionMailer::Base`, which actionmailer/lib/action_mailer/railtie.rb:40
+        #   includes `AbstractController::UrlFor` into, whose `ActionDispatch::Routing::UrlFor` includes
+        #   `PolymorphicRoutes` (action_dispatch/routing/url_for.rb:92). (`polymorphic_path` / `polymorphic_url` are in {BUILTIN_PASSTHROUGH}.)
+        FRAMEWORK_CONTROLLERS = %w[
+          AbstractController::Base ActionController::Metal ActionController::Base ActionController::API
+          ActionMailer::Base
+        ].freeze
+        VIEW_PATH_BASES = %w[ActionController::Base ActionController::API ActionMailer::Base].freeze
+        URL_FOR_BASES = %w[ActionController::Base ActionController::API ActionMailer::Base].freeze
+        FRAMEWORK_METHODS = {
+          "controller_path" => FRAMEWORK_CONTROLLERS,
+          "append_view_path" => VIEW_PATH_BASES,
+          "prepend_view_path" => VIEW_PATH_BASES,
+          "helpers_path" => %w[ActionController::Base].freeze,
+          "edit_polymorphic_path" => URL_FOR_BASES,
+          "edit_polymorphic_url" => URL_FOR_BASES,
+          "new_polymorphic_path" => URL_FOR_BASES,
+          "new_polymorphic_url" => URL_FOR_BASES
+        }.freeze
+
+        # What a call site's lexical position says about `self`: the names the enclosing class or module can be
+        # known by, whether the owner is a module, and the kinds (`:instance`, `:singleton`) `self` may be.
+        CallSite = Struct.new(:names, :module_owner, :kinds, keyword_init: true)
+
+        # The {CallSite} of a node under `ancestors` (outermost first), or nil when it is in no class or module,
+        # which leaves the route-table verdict as it was.
+        def call_site(ancestors)
+          owner_index = ancestors.rindex { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+          member_site = member_class_site(ancestors, owner_index)
+          return member_site if member_site
+          return nil if owner_index.nil?
+
+          CallSite.new(names: owner_names(ancestors, owner_index),
+                       module_owner: ancestors[owner_index].is_a?(Prism::ModuleNode),
+                       kinds: self_kinds(ancestors[(owner_index + 1)..]))
+        end
+
+        BOTH_KINDS = %i[instance singleton].freeze
+        MEMBER_CLASS_CONSTRUCTORS = { Struct: :new, Data: :define }.freeze
+
+        # The call site of a node inside the block of `Struct.new(...) { }` / `Data.define(...) { }`, which is the
+        # body of a class the constructor creates: `self` is that class, not the lexical `class` around it (or
+        # none). A plain constant write (`Point = …`, `Outer::Point = …`, nested under the lexical owner) names it,
+        # and the engine knows its members. Everything else declines (`names` empty): an unassigned block, `P ||= …`,
+        # `… end.freeze`, a dynamic path. nil when the node is not in such a block below its lexical owner.
+        def member_class_site(ancestors, owner_index)
+          index = ancestors.rindex { |n| member_class_call?(n) && ancestors[ancestors.index(n) + 1].equal?(n.block) }
+          return nil if index.nil? || (owner_index && index < owner_index)
+
+          kinds = self_kinds(ancestors[(index + 1)..])
+          names = index.positive? ? written_class_names(ancestors, owner_index, ancestors[index - 1], ancestors[index]) : []
+          names = struct_class_names(ancestors[index]) if names.empty?
+          CallSite.new(names: names, module_owner: false, kinds: kinds)
+        end
+
+        # Issue #2968 — `Struct.new("Named", :a) { }` names its class `Struct::Named` without a constant write.
+        def struct_class_names(call)
+          first = call.arguments&.arguments&.first
+          return [] unless call.name == :new && first.is_a?(Prism::StringNode)
+
+          name = first.unescaped
+          name.match?(/\A[A-Z][A-Za-z0-9_]*\z/) ? ["Struct::#{name}"] : []
+        end
+
+        def written_class_names(ancestors, owner_index, written, call)
+          local =
+            case written
+            when Prism::ConstantWriteNode then written.value.equal?(call) ? written.name.to_s : nil
+            when Prism::ConstantPathWriteNode then written.value.equal?(call) ? declared_name(written.target) : nil
+            end
+          return [] if local.nil?
+          return [local.delete_prefix("::")] if local.start_with?("::")
+
+          prefixes = owner_index ? owner_names(ancestors, owner_index) : [""]
+          nested = prefixes.map { |prefix| prefix.empty? ? local : "#{prefix}::#{local}" }
+          # `Outer::R = …` resolves `Outer` lexically or at the root, as a compact `class Foo::Bar` does.
+          written.is_a?(Prism::ConstantPathWriteNode) ? (nested + [local]).uniq : nested
+        end
+
+        def member_class_call?(node)
+          return false unless node.is_a?(Prism::CallNode) && node.block.is_a?(Prism::BlockNode)
+
+          receiver = node.receiver
+          receiver_name =
+            case receiver
+            when Prism::ConstantReadNode then receiver.name
+            when Prism::ConstantPathNode then receiver.parent.nil? ? receiver.name : nil
+            end
+          !receiver_name.nil? && MEMBER_CLASS_CONSTRUCTORS[receiver_name] == node.name
+        end
+
+        # The kinds `self` may be for a node under the nodes between its owner and itself. The nearest `def`
+        # decides (blocks inside a method keep its `self`); with no `def`, a bare class body is the class object
+        # itself, while a block or lambda there may run on another object (`before_action { }`, `included do`,
+        # `define_method`, `Class.new`), so both kinds are asked.
+        def self_kinds(inner)
+          def_index = inner.rindex { |n| n.is_a?(Prism::DefNode) }
+          if def_index
+            node = inner[def_index]
+            return BOTH_KINDS if node.receiver && !node.receiver.is_a?(Prism::SelfNode)
+            return [:singleton] if node.receiver
+
+            return inner[0...def_index].any?(Prism::SingletonClassNode) ? [:singleton] : [:instance]
+          end
+          return BOTH_KINDS if inner.any? { |n| block_scope?(n) }
+          if inner.any? { |n| n.is_a?(Prism::SingletonClassNode) && !n.expression.is_a?(Prism::SelfNode) }
+            return BOTH_KINDS
+          end
+
+          [:singleton]
+        end
+
+        def block_scope?(node)
+          node.is_a?(Prism::BlockNode) || node.is_a?(Prism::LambdaNode)
+        end
+
+        # The names the enclosing class or module can be known by, `[]` when a declaration's name is dynamic. A
+        # bare `class Foo` is exactly `Enclosing::Foo`. A compact `class Foo::Bar` may resolve `Foo` lexically or
+        # at the root, so both spellings are tried. A rooted declaration (`class ::Foo`) names the root constant
+        # alone.
+        def owner_names(ancestors, owner_index)
+          chain = ancestors[0..owner_index].select { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+          names = [""]
+          chain.each do |decl|
+            local = declared_name(decl.constant_path)
+            return [] if local.nil?
+
+            names = if local.start_with?("::")
+                      [local.delete_prefix("::")]
+                    else
+                      nested = names.map { |prefix| prefix.empty? ? local : "#{prefix}::#{local}" }
+                      decl.constant_path.is_a?(Prism::ConstantPathNode) ? (nested + [local]).uniq : nested
+                    end
+          end
+          names
+        end
+
+        def declared_name(node)
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode
+            return "::#{node.name}" if node.parent.nil?
+
+            parent = declared_name(node.parent)
+            parent && "#{parent}::#{node.name}"
+          end
+        end
+
         # Walks the AST once and returns the Set of names that shadow a route helper for this file. Includes:
         #
         # - `def name` declarations (any level — the per-method-scope visibility model Ruby uses means a
@@ -124,7 +322,6 @@ module Rigor
           if name
             names << name
           elsif call_node.name == :subject && call_node.arguments.nil?
-            # Bare `subject { ... }` defines `:subject` itself.
             names << "subject"
           end
         end
@@ -201,8 +398,7 @@ module Rigor
         end
 
         def unknown_helper_violation(name, helper_table)
-          # ADR-39 / boilerplate 0c — the shared DidYouMean-backed suggester replaces the hand-rolled
-          # Levenshtein this module used to carry.
+          # ADR-39 / boilerplate 0c — the shared DidYouMean-backed suggester.
           suggestion = Rigor::Plugin::Base.suggest(name, helper_table.names)
           message = "no route helper `#{name}`"
           message += " (did you mean `#{suggestion}`?)" if suggestion

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:
     #
@@ -205,11 +205,12 @@ module Rigor
         Analyzer.collect_shadowing_names(root)
       end
 
-      node_rule Prism::CallNode do |node, _scope, path, shadowing|
+      node_rule Prism::CallNode do |node, scope, path, shadowing, context|
         table = helper_table_or_nil
         next [] if table.nil? || table.empty?
 
-        Analyzer.violations_for(call_node: node, helper_table: table, shadowing: shadowing, path: path).map do |violation|
+        Analyzer.violations_for(call_node: node, helper_table: table, shadowing: shadowing, path: path,
+                                scope: scope, context: context).map do |violation|
           diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
         end
       end

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

@@ -286,8 +286,8 @@ module Rigor
         # project class, which says nothing about who wrote `==`.
         def project_defines?(class_name, operator, scope)
           OPERATOR_OWNER_CHAINS.fetch([class_name, operator]).any? do |name|
-            !scope.user_def_through_ancestors(name, operator).first.nil? ||
-              scope.discovered_method_through_ancestors?(name, operator, :instance)
+            !Rigor::Reflection.project_method_defined(name, operator, kind: :instance, source: :either,
+                                                                      scope: scope).no?
           end
         end
 
@@ -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?
 
@@ -390,8 +390,8 @@ module Rigor
         # `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)
+            !Rigor::Reflection.project_method_defined(name, method_name, kind: :instance, source: :either,
+                                                                         scope: scope).no?
           end
         end
 

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?