rigortype 0.4.7 → 0.4.8

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

@@ -65,6 +65,14 @@ module Rigor
       manifest(
         id: "activerecord",
         target_gems: ["activerecord"],
+        # 0.16.0, 2026-11-13 (#2956) — the `id` column takes the primary key's type (`id: :uuid` reads `String`)
+        # instead of always `Integer`, and `serial` / `bigserial` columns read `Integer`. The schema table
+        # payload changes, so the bump follows the 0.15.0 entry.
+        #
+        # 0.15.0, 2026-11-07 (#2945) — `create_table`'s `primary_key: "name"` registers that column, so a query
+        # on it, or on an `alias_attribute` targeting it, no longer reports `unknown-column`. The schema table
+        # payload changes, and the bump (part of the producer cache KEY) stops a warm run serving the old one.
+        #
         # 0.14.0, 2026-10-10 (#1721) — the plugin publishes `:reachability_roots`: the models ActiveRecord loads
         # by name from an association. The association rows gain `macro`, `class_name_option`, `through` and
         # `source_type_option`, so a cached 0.13.0 payload lacks the fields the roots are derived from and
@@ -124,7 +132,7 @@ module Rigor
         # a scope lambda body / class-method body now contributes `Relation[Model]` via `scope.self_type`
         # instead of falling through to `Kernel#select` (the IO multiplexer, `Array[String]` return). Plus
         # `:select` added to the relation-entry-point list.
-        version: "0.14.0",
+        version: "0.16.0",
         description: "Types ActiveRecord finders against the project's db/schema.rb and AR models.",
         config_schema: {
           "schema_file" => { kind: :string, default: "db/schema.rb" },
@@ -491,8 +499,8 @@ module Rigor
       # The project's OWN definition wins, and is not merely a precision preference: `def name` on the
       # model — or on an ancestor it declares — is an override Ruby dispatches to, and the plugin tier sits
       # ABOVE the engine's body-inference tiers, so answering here would displace the override's real return
-      # type with `Dynamic`. `discovered_method_through_ancestors?` is the same table the veto's own
-      # discovery arm reads, and it fails toward declining (a budget-exhausted walk answers true).
+      # type with `Dynamic`. `Reflection.project_method_defined(source: :discovered)` is the same table the veto's own
+      # discovery arm reads, and it fails toward declining (a budget-exhausted walk answers `maybe`).
       def implicit_self_instance_member_type(call_node, scope, index)
         return nil if scope.nil?
         return nil unless call_node.arguments.nil?
@@ -504,7 +512,9 @@ module Rigor
         entry = index.find(self_type.class_name)
         return nil if entry.nil?
         return nil unless instance_member_name?(entry, call_node.name)
-        return nil if scope.discovered_method_through_ancestors?(self_type.class_name, call_node.name, :instance)
+        return nil unless Rigor::Reflection.project_method_defined(
+          self_type.class_name, call_node.name, kind: :instance, source: :discovered, scope: scope
+        ).no?
         return nil if rbs_answers_before_object?(self_type.class_name, call_node.name, scope)
 
         Rigor::Type::Combinator.untyped
@@ -552,6 +562,18 @@ module Rigor
         !entry.column(column_name).nil?
       end
 
+      # A project `self.find` on the model or an ancestor, or a walk that ran out of budget before ruling one out
+      # (`maybe`): the veto fails toward declining, as the discovery walk always has.
+      def project_find_defined?(entry, scope)
+        project_singleton_defined?(entry, :find, scope)
+      end
+
+      # The same veto for any class-side selector the plugin answers in Rails' name (`find`, `select`).
+      def project_singleton_defined?(entry, name, scope)
+        !Rigor::Reflection.project_method_defined(entry.class_name, name, kind: :singleton, source: :discovered,
+                                                                          scope: scope).no?
+      end
+
       # Class-side finders + the class-side relation entry points. `find` returns the model, or an Array of
       # them for two or more ids, or with a block the model or `nil`; `find_by!` returns the model;
       # `find_by` adds the `nil` arm; `where` / `all` / `order` / `limit` / `none` open a relation. The
@@ -572,7 +594,7 @@ module Rigor
 
           # A model that defines its own `self.find` (`find(owner, id)`) takes two arguments for its own
           # reasons, so the Array reading of Rails' `find` is withheld and the project's method answers.
-          return nil if scope.discovered_method_through_ancestors?(entry.class_name, :find, :singleton)
+          return nil if project_find_defined?(entry, scope)
 
           Rigor::Type::Combinator.nominal_of("Array", type_args: [model])
         when :find_by!
@@ -584,13 +606,10 @@ module Rigor
             Rigor::Type::Combinator.nominal_of(entry.class_name),
             Rigor::Type::Combinator.constant_of(nil)
           )
-        when :where, :all, :order, :limit, :none, :select
-          # `:select` was added to close Mastodon's
-          # `scope :duplicate_uris, -> { select(:uri).group(:uri).having(...) }` shape: the implicit-self
-          # `select(:uri)` inside the scope lambda body had been resolving to `Kernel#select` (IO
-          # multiplexer, return `Array[String]`), masking the AR class-side relation entry point. The rest
-          # of the query DSL chains through the bundled `ActiveRecord::Relation` RBS once a relation is
-          # open.
+        when :select then class_select_return_type(call_node, entry, scope)
+        when :where, :all, :order, :limit, :none
+          # The rest of the query DSL chains through the bundled `ActiveRecord::Relation` RBS once a
+          # relation is open.
           relation_of(entry.class_name)
         when :table_name
           table_name_return_type(entry)
@@ -601,6 +620,23 @@ module Rigor
         end
       end
 
+      # `:select` was added to close Mastodon's `scope :duplicate_uris, -> { select(:uri).group(:uri).having(...) }`
+      # shape: the implicit-self `select(:uri)` inside the scope lambda body had been resolving to `Kernel#select`
+      # (IO multiplexer, return `Array[String]`), masking the AR class-side relation entry point.
+      #
+      # `Model.select` is `all.select`, so a block makes it `Enumerable#select` over the loaded records, as the
+      # bundled `Relation#select` overload says (#1408), and the answer is an Array of the model. Fields next to a
+      # block answer the Array too, for the reason given on that overload. A model that defines its own
+      # `self.select` keeps its own answer for the block forms, as it does for `find`'s block and multi-id
+      # forms (`project_find_defined?`); the builder form stays the relation, as `find`'s one-id form stays the
+      # model.
+      def class_select_return_type(call_node, entry, scope)
+        return relation_of(entry.class_name) if call_node.block.nil?
+        return nil if project_singleton_defined?(entry, :select, scope)
+
+        Rigor::Type::Combinator.nominal_of("Array", type_args: [Rigor::Type::Combinator.nominal_of(entry.class_name)])
+      end
+
       # `Model.find { |m| … }` / `Model.find(&:pred?)` never reaches the id lookup: `Core.find` passes a
       # block to `super` (`all.find`), whose `Relation#find` does `return super if block_given?`, landing on
       # `Enumerable#find` over the loaded records. So the answer is the element or `nil`, exactly what the
@@ -615,7 +651,7 @@ module Rigor
       # `Relation#find` overload does. A project `self.find` keeps its own answer, as it does for the
       # multi-id form.
       def block_find_return_type(call_node, entry, scope)
-        return nil if scope.discovered_method_through_ancestors?(entry.class_name, :find, :singleton)
+        return nil if project_find_defined?(entry, scope)
         return Rigor::Type::Combinator.untyped unless call_argument_count(call_node).zero?
 
         Rigor::Type::Combinator.union(

data/plugins/rigor-activerecord/sig/active_record/relation.rbs

@@ -231,12 +231,26 @@ module ActiveRecord
     def left_outer_joins: (*untyped) -> self
     %a{pure}
     def references: (*untyped) -> self
-    # With a block, `select` is Enumerable's and returns an Array. It
-    # stays `self`: on this open receiver a method the file does not
-    # declare is not reported, while on `Array[Elem]` any ActiveSupport
-    # method the bundled overlay leaves out would be.
+    # With a block, `select` is `Enumerable#select` over the loaded
+    # records and returns an Array (`return super()` when a block is
+    # given, `relation/query_methods.rb:413` in activerecord 8.1.3.1).
+    # Fields and a block together raise `ArgumentError` there; Rails 4
+    # ignored the fields and returned the Array, so that form answers
+    # the Array too, which holds on either version. Without a block it
+    # is the query builder.
+    #
+    # `Array[Elem]` is a closed receiver, unlike this one: an
+    # ActiveSupport Array method on the result (`pluck`, `second`,
+    # `to_sentence`, `blank?`) resolves only with the
+    # `rigor-activesupport-core-ext` plugin enabled, and reports
+    # `call.undefined-method` without it, as it does after `to_a`.
+    #
+    # The `%a{pure}` is the builder form's. The block form's
+    # `io.db.read` comes from the plugin's `RELATION_MATERIALIZERS` row,
+    # which labels both forms today (#1318).
     %a{pure}
-    def select: (*untyped) -> self
+    def select: (*untyped) { (Elem) -> boolish } -> Array[Elem]
+              | (*untyped) -> self
     %a{pure}
     def reselect: (*untyped) -> self
     %a{pure}

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

@@ -89,13 +89,15 @@ module Rigor
       # decline — they take side-effecting argument types that the RBS surface already covers.
       dynamic_return receivers: -> { attachment_index&.class_names || [] } do |call_node, scope|
         next nil unless call_node.is_a?(Prism::CallNode)
-        next nil if call_node.receiver.nil?
+
+        receiver = call_node.receiver
+        next nil if receiver.nil?
         next nil unless call_node.arguments.nil?
 
         index = attachment_index
         next nil if index.nil? || index.empty?
 
-        receiver_type = scope.type_of(call_node.receiver)
+        receiver_type = scope.type_of(receiver)
         next nil unless receiver_type.is_a?(Rigor::Type::Nominal)
 
         # `AttachmentIndex#attachments_for` de-roots the query itself (#621) — no retry arm here.

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

@@ -132,10 +132,12 @@ module Rigor
 
       dynamic_return methods: DURATION_MULTIPLIERS do |call_node, scope|
         next nil unless call_node.is_a?(Prism::CallNode)
-        next nil unless call_node.receiver # `day` with no receiver is somebody's own method
+
+        receiver = call_node.receiver
+        next nil unless receiver # `day` with no receiver is somebody's own method
         next nil unless call_node.arguments.nil?
         next nil unless call_node.block.nil?
-        next nil unless numeric_receiver?(scope&.type_of(call_node.receiver))
+        next nil unless numeric_receiver?(scope&.type_of(receiver))
 
         Rigor::Type::Combinator.nominal_of(DURATION_NOMINAL)
       end
@@ -200,7 +202,11 @@ module Rigor
         argument_kind = duration_operand_kind(scope&.type_of(argument))
         next nil if argument_kind.nil?
 
-        receiver_kind = duration_operand_kind(scope&.type_of(call_node.receiver))
+        receiver = call_node.receiver
+        # Prism gives every parsed `+` / `-` / `*` call a receiver; the guard is for the RBS `Node?` type.
+        next nil if receiver.nil?
+
+        receiver_kind = duration_operand_kind(scope&.type_of(receiver))
         next nil if receiver_kind.nil?
 
         duration_arithmetic_result(call_node.name, receiver_kind, argument_kind)
@@ -210,11 +216,13 @@ module Rigor
       # member; see {SymbolizeKeys}. The RBS rows answer `Hash[untyped, V]` wherever this declines.
       dynamic_return methods: %i[symbolize_keys to_options] do |call_node, scope|
         next nil unless call_node.is_a?(Prism::CallNode)
-        next nil unless call_node.receiver
+
+        receiver = call_node.receiver
+        next nil unless receiver
         next nil unless call_node.arguments.nil?
 
         # A block is ignored by `symbolize_keys`, so it does not decline.
-        SymbolizeKeys.result(scope&.type_of(call_node.receiver), scope)
+        SymbolizeKeys.result(scope&.type_of(receiver), scope)
       end
 
       # ADR-88 WD1 — both tables are static and the RBS bundle ships with the gem; nothing here reads a

data/plugins/rigor-activesupport-core-ext/sig/active_support/core_ext.rbs

@@ -604,6 +604,35 @@ class Float
   def gigabytes: () -> Float
 end
 
+# ---------------------------------------------------------------
+# NumericWithFormat — ActiveSupport's `core_ext/numeric/conversions`, included into Integer, Float and
+# BigDecimal. Declared on the module and included, not as a `def` on each class, so a project `sig/` that
+# declares `Integer#to_fs` itself overrides it instead of raising `DuplicatedMethodDefinitionError` (the
+# `process.rbs` shape). Not pure: the Symbol formats read `I18n` for their locale. An Integer or String
+# format is `to_s(format)`, and no format is `to_s`, so every form answers a String. `options` is any
+# Hash-like value: ActiveSupport calls `symbolize_keys` on it, so String keys and a HashWithIndifferentAccess
+# are both valid.
+# ---------------------------------------------------------------
+
+module ActiveSupport
+  module NumericWithFormat
+    def to_fs: (?(Symbol | Integer | String | nil) format, ?Hash[untyped, untyped]? options) -> String
+    def to_formatted_s: (?(Symbol | Integer | String | nil) format, ?Hash[untyped, untyped]? options) -> String
+  end
+end
+
+class Integer
+  include ActiveSupport::NumericWithFormat
+end
+
+class Float
+  include ActiveSupport::NumericWithFormat
+end
+
+class BigDecimal
+  include ActiveSupport::NumericWithFormat
+end
+
 # ---------------------------------------------------------------
 # ActiveSupport::Duration — issue #632
 # ---------------------------------------------------------------

data/plugins/rigor-alba/lib/rigor/plugin/alba/resource_collector.rb

@@ -2,24 +2,22 @@
 
 require "prism"
 
-require "rigor/inference/declaration_walk"
+require "rigor/reflection"
 
 require_relative "resource_index"
 
 module Rigor
   module Plugin
     class Alba < Rigor::Plugin::Base
-      # A {Rigor::Inference::DeclarationWalk} collector over one file: the classes it declares, whether each
-      # `include Alba::Resource`s, and the association declarations whose resource
-      # class alba infers from the name.
+      # A collector over one file, built on {Rigor::Reflection.class_declarations_in}: the classes it declares, whether
+      # each `include Alba::Resource`s, and the association declarations whose resource class alba infers from
+      # the name.
       #
       # An association is recorded only when alba would take the inference path (`Alba::Association#
       # resource_from`): a literal Symbol/String name, exactly one positional argument, no block, and no
       # `resource:` / `serializer:` keyword. A keyword splat (`**opts`) might carry either, so it is not
       # recorded either — a skipped association costs a root, never invents one.
       class ResourceCollector
-        include Rigor::Inference::DeclarationWalk::Collector
-
         ASSOCIATION_METHODS = %i[association one many has_one has_many].freeze
         RESOURCE_MODULE = "Alba::Resource"
         RESOURCE_KEYWORDS = %i[resource serializer].freeze
@@ -40,22 +38,13 @@ module Rigor
           @associations = []
         end
 
-        def on_declaration(node, context, body_context)
-          return Rigor::Inference::DeclarationWalk::DESCEND unless node.is_a?(Prism::ClassNode)
-
-          name = body_context.prefix.join("::")
-          unless name.empty?
-            @entries[name] = superclass_name(node.superclass)
-            @nestings[name] = context.nesting || []
+        # Walks `root` (a parsed file's `Prism::Node`) and records what it finds; answers the collector itself.
+        def collect(root)
+          Rigor::Reflection.class_declarations_in(root) { |call| on_call(call.node, call.owner) }.each do |declaration|
+            @entries[declaration.name] = superclass_name(declaration.node.superclass)
+            @nestings[declaration.name] = declaration.nesting
           end
-          Rigor::Inference::DeclarationWalk::DESCEND
-        end
-
-        def on_call(node, context)
-          owner = context.prefix.join("::")
-          record_call(node, owner) unless owner.empty? || !node.receiver.nil?
-          remember_block(node)
-          Rigor::Inference::DeclarationWalk::DESCEND
+          self
         end
 
         # The classes this file declares, as {ResourceIndex::ClassEntry} values.
@@ -70,6 +59,11 @@ module Rigor
 
         private
 
+        def on_call(node, owner)
+          record_call(node, owner) unless owner.nil? || !node.receiver.nil?
+          remember_block(node)
+        end
+
         def record_call(node, owner)
           if node.name == :include
             @includes[owner] = true if includes_resource?(node)

data/plugins/rigor-alba/lib/rigor/plugin/alba/resource_discoverer.rb

@@ -2,8 +2,6 @@
 
 require "prism"
 
-require "rigor/inference/declaration_walk"
-
 require_relative "resource_collector"
 require_relative "resource_index"
 
@@ -28,10 +26,7 @@ module Rigor
             parsed = Prism.parse(contents)
             next unless parsed.success?
 
-            collector = ResourceCollector.new
-            Rigor::Inference::DeclarationWalk.run(
-              parsed.value, [collector], Rigor::Inference::DeclarationWalk::Context.root(nesting: [])
-            )
+            collector = ResourceCollector.new.collect(parsed.value)
             entries.concat(collector.class_entries)
             associations.concat(collector.associations)
           end

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

@@ -47,7 +47,8 @@ module Rigor
         catalog = producer_value(:ffi_catalog)
         next nil if catalog.nil?
 
-        receiver_type = call_node.receiver ? scope&.type_of(call_node.receiver) : scope&.self_type
+        receiver = call_node.receiver
+        receiver_type = receiver ? scope&.type_of(receiver) : scope&.self_type
         receiver_class = case receiver_type
                          when Rigor::Type::Nominal, Rigor::Type::Singleton then receiver_type.class_name
                          end
@@ -77,7 +78,8 @@ module Rigor
         catalog = producer_value(:ffi_catalog)
         next nil if catalog.nil?
 
-        receiver_type = call_node.receiver ? scope&.type_of(call_node.receiver) : scope&.self_type
+        receiver = call_node.receiver
+        receiver_type = receiver ? scope&.type_of(receiver) : scope&.self_type
         receiver_class = case receiver_type
                          when Rigor::Type::Nominal, Rigor::Type::Singleton then receiver_type.class_name
                          end

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

@@ -77,8 +77,18 @@ module Rigor
         signature_paths: ["sig"],
         # ADR-43 WD4 — the classes the bundled sig covers completely enough that a Ruby-source subclass
         # (`class PostType < GraphQL::Schema::Object`) may bridge inherited calls to the RBS ancestor.
-        # Listing one turns on `call.undefined-method`/arity checks for inherited DSL calls on every
-        # subclass — justified here because the sig IS the authority (graphql-ruby ships none).
+        # The bridge is a signature lookup only: an inherited DSL call resolves to the declaration's
+        # return type and block parameters, and a subclass `def` overriding a declared method other
+        # than `initialize` binds its parameters from it (#2681). The subclass itself stays outside
+        # RBS, so no signature-reading call rule fires on a call it makes, declared or not:
+        # `call.undefined-method`, `call.wrong-arity` and `call.argument-type-mismatch` all stay
+        # silent, while the same calls on a listed class AS THE DIRECT RECEIVER still report.
+        # `open_receivers:` is what covers those direct receivers; it is not what silences the
+        # subclass — the receiver gate is (ADR-43 Context § "Amendment 2026-11-15", which withdrew
+        # the claim that the rules follow the resolution). So listing a class here cannot cost a
+        # false positive on a subclass. The risk runs the other way: a declared member that does not exist at runtime makes a genuinely
+        # failing call resolve silently, so the sig must be accurate — it IS the authority
+        # (graphql-ruby ships none).
         rbs_complete_ancestors: %w[
           GraphQL::Schema
           GraphQL::Schema::Member

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

@@ -113,7 +113,13 @@ module Rigor
       # ADR-37 slice 2 — a pure return-type contributor. The engine gates on the receiver being a known
       # carrier class (so the block only runs on Result/Option receivers); the block then confirms the call
       # is an unwrap method on an instantiated carrier and yields the carried `type_args[0]`.
+      # #2717 — the rule has no `methods:` gate, so the name gate does not screen it: the engine also offers it
+      # the compound-write nodes (`x.attr op= v`, `x[i] ||= v`, ...) and the `&:symbol` block's
+      # `Prism::BlockArgumentNode`. None of those has `name`, which the rule reads after `receiver`, so decline
+      # anything that is not a `CallNode` rather than raise into the rescue.
       dynamic_return receivers: (RESULT_CARRIERS + OPTION_CARRIERS) do |call_node, scope|
+        next nil unless call_node.is_a?(Prism::CallNode)
+
         receiver = call_node.receiver
         next nil if receiver.nil?
 

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

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

@@ -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