rigortype 0.4.5 → 0.4.7

data/lib/rigor/inference/method_dispatcher/singleton_folding.rb

@@ -20,7 +20,6 @@ module Rigor
       #
       # Centralising both here keeps the receiver-shape and constant-unwrap knowledge in one place: if
       # `Type::Singleton` or `Type::Constant` ever changes shape, there is a single edit rather than nine.
-      # The per-tier fold bodies stay where they are — only the shared gate moves.
       module SingletonFolding
         module_function
 

data/lib/rigor/inference/method_dispatcher/singleton_mixin_dispatch.rb

@@ -20,8 +20,9 @@ module Rigor
       # The rule is exact rather than heuristic — the receiver must be a `Singleton[C]` whose `C` the project
       # pre-pass recorded as including `Singleton` — so a class that does not include the mixin is untouched,
       # and a project that defines its own `Singleton` module is the one case that would misfire. Guarded by
-      # {project_singleton_shadow?}: a project-declared `Singleton` class or module wins and the tier declines,
-      # because then the name means something else entirely.
+      # {own_singleton_include?}: when the included name resolves to a project-declared class or module (a
+      # top-level `Singleton`, or `M::Singleton` inside `module M`), the tier declines, because then the name
+      # means something else entirely.
       module SingletonMixinDispatch
         MIXIN_NAMES = Ractor.make_shareable(Set["Singleton", "::Singleton"])
         private_constant :MIXIN_NAMES
@@ -31,30 +32,62 @@ module Rigor
 
         module_function
 
-        # @return `Nominal[C]` for `C.instance`, or nil to decline.
+        # @return the instance type of `C` for `C.instance`, or nil to decline.
         def try_dispatch(context)
-          return nil unless context.method_name == SELECTOR
-          return nil unless context.args.empty?
-
           receiver = context.receiver
-          return nil unless receiver.is_a?(Type::Singleton)
-
-          scope = context.scope
-          return nil if scope.nil?
-          return nil unless includes_singleton_mixin?(scope, receiver.class_name)
-          return nil if project_singleton_shadow?(scope)
+          return nil unless answers?(context.scope, receiver, context.method_name, context.args.empty?)
 
           Type::Combinator.nominal_of(receiver.class_name)
         end
 
+        # Issue #2438 — the one predicate behind {try_dispatch} and `CheckRules#undefined_method_diagnostic`, so the
+        # typer and the `call.undefined-method` rule cannot disagree about `C.instance`: a call this tier types is
+        # never reported as undefined, whatever a project sidecar of `C` lists.
+        def answers?(scope, receiver, method_name, no_arguments)
+          return false unless method_name == SELECTOR && no_arguments
+          return false unless receiver.is_a?(Type::Singleton)
+          return false if scope.nil?
+
+          includes_singleton_mixin?(scope, receiver.class_name)
+        end
+
+        # True when `class_name`'s instance ancestry carries the stdlib `Singleton` as an `include` written in the
+        # class itself or in a project class up its superclass chain (Ruby's `Singleton.included` also installs an
+        # `inherited` hook, so `class D < C` answers `instance` with its own instance). Read off
+        # `Scope::ResolutionChain` (the `:constants` flavor, so an empty project `module Singleton` is a project
+        # entry), where the stdlib module is an external entry. Issue #2438 — what is not the mixin:
+        #
+        # - `prepend Singleton`, which runs `prepend_features` instead of the `included` hook and so defines no
+        #   `instance`; a prepended entry sits ahead of its owner on the chain;
+        # - an `include Singleton` in a MODULE the class includes: `Singleton.included` raises `TypeError` for a
+        #   module, so that code never runs;
+        # - a top-level project `Singleton`, which both `Singleton` and `::Singleton` name.
+        #
+        # A NESTED project `N::Singleton` the name resolved to is read as the stdlib mixin: the discovery tables
+        # drop the leading `::` of a mixin argument, so `include ::Singleton` and `include Singleton` inside
+        # `module N` record the same name, and the stdlib reading is the one that types the rooted spelling and
+        # never reports a correct call.
         def includes_singleton_mixin?(scope, class_name)
-          scope.includes_of(class_name).any? { |name| MIXIN_NAMES.include?(name.to_s) }
+          chain = Scope::ResolutionChain.for(scope, class_name.to_s.delete_prefix("::"), :instance, :constants)
+          chain.record(scope)
+          classes = chain.level_classes.compact
+          chain.entries.each_with_index.any? { |entry, index| singleton_include?(chain, classes, entry, index) }
+        end
+
+        def singleton_include?(chain, classes, entry, index)
+          if entry.external?
+            !entry.superclass_edge && MIXIN_NAMES.include?(entry.raw.to_s) && classes.include?(entry.owner) &&
+              index > chain.index_of(entry.owner)
+          else
+            entry.name.end_with?("::Singleton") && included_by_level_class?(chain, index)
+          end
         end
 
-        # True when the project declares its OWN `Singleton` class / module, in which case `include Singleton`
-        # names that one and the stdlib rule does not apply.
-        def project_singleton_shadow?(scope)
-          MIXIN_NAMES.any? { |name| scope.discovery.discovered_classes.key?(name.to_s.delete_prefix("::")) }
+        # The entry sits after its level's class, so it was included into that level rather than prepended.
+        def included_by_level_class?(chain, index)
+          level = chain.level_starts.rindex { |start| start <= index }
+          klass = level && chain.level_classes[level]
+          !klass.nil? && index > chain.index_of(klass)
         end
       end
     end

data/lib/rigor/inference/method_dispatcher/struct_folding.rb

@@ -14,8 +14,8 @@ module Rigor
       #
       # A `Struct` instance is mutable (`s.x = v`, `s[:x] = v`, escape), so a member map bound to a
       # variable can be invalidated by a later write. A member read folds off a **fresh** instance (the
-      # transient receiver of a `.new(...).x` / `.with(...).x` chain, unmutatable between materialisation
-      # and the read — slices 1+2), off a **fold-safe stored local** the {Inference::StructFoldSafety} scan
+      # transient receiver of a `.new(...).x` chain, unmutatable between materialisation and the read —
+      # slices 1+2), off a **fold-safe stored local** the {Inference::StructFoldSafety} scan
       # proved is never mutated / aliased / escaped (slice 3), or off a **setter-mutated fold-safe local**
       # whose bindings {#apply_setter_writeback} keeps current (slice 4). Any other stored receiver degrades
       # to `Dynamic[top]` rather than fold a possibly-stale value.
@@ -255,8 +255,8 @@ module Rigor
         end
 
         # A member read is foldable when the receiver is either FRESH (the transient result of a
-        # `.new(...)`/`.with(...)` chain, which cannot have been mutated between materialisation and this
-        # read) or a FOLD-SAFE stored local (ADR-48 slice 3 — `StructFoldSafety` proved the binding is
+        # `.new(...)` chain, which cannot have been mutated between materialisation and this read) or a
+        # FOLD-SAFE stored local (ADR-48 slice 3 — `StructFoldSafety` proved the binding is
         # never mutated / aliased / escaped in its scope).
         def foldable_receiver?(context)
           fresh_receiver?(context) || fold_safe_local_receiver?(context) ||
@@ -308,7 +308,7 @@ module Rigor
         end
 
         # A fresh receiver is the result of a chained call that MATERIALISED the struct — `Point.new(1, 2).x`,
-        # `Point[1, 2].x`, `inst.with(x: 9).y`. Not merely a chained call: slices 1-2 read "chained" as
+        # `Point[1, 2].x`. Not merely a chained call: slices 1-2 read "chained" as
         # "cannot have been mutated between materialisation and the read", and a method that hands back its
         # own receiver falsifies that (issue #595):
         #

data/lib/rigor/inference/method_dispatcher/struct_materialization.rb

@@ -31,12 +31,10 @@ module Rigor
         # nodes; the bound exists so a pathological body cannot turn a per-call-site gate into a walk.
         FACTORY_BODY_SCAN_BUDGET = 200
 
-        # Issue #595 / #525 — the ONE materialisation test. Both places that must answer "was this receiver
-        # expression's struct newly built?" go through it: this module's direct member-read gate above, and
-        # `ExpressionTyper`'s caller-side `:self`-grant arm. They had forked answers once (the grant arm was
-        # tightened for #591 while this one still trusted any chained call), so both consumers must share this
-        # one answer. A `.with` call is never a materialisation: the composed `x.dup_self.with(indent: 9)`
-        # shape once slipped through as one, and `Struct#with` no longer exists to fold (#1335).
+        # Issue #595 / #525 — the ONE materialisation test, shared by {StructFolding#fresh_receiver?} and
+        # `ExpressionTyper`'s `:self`-grant arm so the two gates cannot fork. A `.with` call is never a
+        # materialisation: the composed `x.dup_self.with(indent: 9)` shape once slipped through as one, and
+        # `Struct#with` no longer exists (#1335).
         #
         # @param node — the receiver EXPRESSION.
         # @param scope — the scope the factory and ancestor lookups resolve against.

data/lib/rigor/inference/method_dispatcher/uri_folding.rb

@@ -55,7 +55,7 @@ module Rigor
 
         # A form long enough to suggest generated or accumulated data rather than a literal a reader wrote;
         # past it the folded `Constant[String]` stops being useful in a diagnostic and only costs memory.
-        # Mirrors the byte ceiling `ShapeDispatch`'s own `tuple_join` fold applies for the same reason.
+        # Counts pairs where `ShapeDispatch`'s `tuple_join` fold caps bytes, for the same reason.
         FORM_PAIR_LIMIT = 64
         private_constant :FORM_PAIR_LIMIT
 

data/lib/rigor/inference/method_dispatcher.rb

@@ -41,6 +41,7 @@ require_relative "method_dispatcher/universal_object_dispatch"
 require_relative "method_dispatcher/singleton_mixin_dispatch"
 require_relative "method_dispatcher/method_folding"
 require_relative "method_dispatcher/optional_count"
+require_relative "../run_scoped_slots"
 
 module Rigor
   module Inference
@@ -204,8 +205,8 @@ module Rigor
         # user-authored RBS overrides substrate synthesis) and ABOVE the dependency-source
         # inference tier so a plugin's declared emit table beats the generic gem-source fallback
         # for the same class. Slice 6a-TierB (origin_module dispatch) lands precise return types
-        # for Tier B emissions; Tier C emissions still return `Dynamic[T]` at this tier (slice 6b
-        # is the Tier C promotion via ADR-13's resolver chain).
+        # for Tier B emissions; Tier C emissions return their manifest `return_type` when the environment
+        # names that class (slice 6b), and `Dynamic[T]` otherwise.
         synthetic_result = try_synthetic_method(
           receiver_type, method_name, arg_types, block_type, environment
         )
@@ -535,10 +536,9 @@ module Rigor
       # The question is asked HERE, of the same two tiers `resolve` consults and in the same order, rather
       # than reconstructed in the veto: a name this reports as answered is a name the dispatch really would
       # resolve, and no plugin knowledge moves into the engine's veto. The tiers are the gated
-      # `dynamic_return` walk and the ADR-16 synthetic-method index (Tier C `heredoc_templates` emissions
-      # today; the Tier B `Plugin::Macro::TraitRegistry` explosions share that table but cannot populate it
-      # until #476 threads a real environment into the pre-pass that builds it, so no trait member reaches
-      # this predicate in production yet — it will when #476 lands, with no change here).
+      # `dynamic_return` walk and the ADR-16 synthetic-method index (Tier C `heredoc_templates` emissions and
+      # the Tier B `Plugin::Macro::TraitRegistry` explosions, which share that table; since #476 the pre-pass
+      # explodes a trait module whenever the project's RBS declares it).
       #
       # It is a predicate, not a type: the veto's job is to stop the top-level bind, after which the call
       # falls through to the ordinary dispatch chain and the tier that answered here answers there too. The
@@ -916,8 +916,7 @@ module Rigor
         result || EMPTY_CONTRIBUTIONS
       end
 
-      # Runs the precision tiers (constant fold, shape dispatch, file-path fold, block fold) in
-      # order and returns the first non-nil answer. Each tier owns its own receiver/argument
+      # Runs the precision tiers in order and returns the first non-nil answer. Each tier owns its own receiver/argument
       # shape checks; a tier that does not recognise the receiver returns nil so the next tier
       # can try. The RBS tier sits below this chain and is invoked by the outer `dispatch`
       # method.
@@ -926,7 +925,7 @@ module Rigor
       # (`try_dispatch(CallContext) -> Type?`). Order is significant: ConstantFolding's
       # exact-value folds win first, the stdlib singleton folders sit in the middle (each
       # gates on a distinct `Singleton` receiver, so their relative order is immaterial), and
-      # BlockFolding runs last because its rules only apply to block-taking calls — the cheaper
+      # BlockFolding runs near the end because its rules only apply to block-taking calls — the cheaper
       # arity folds above it filter the common cases first. Adding a precise tier is a one-line
       # append here rather than another link in a hand-written `||` ladder.
       PRECISE_TIERS_HEAD = Ractor.make_shareable([
@@ -1031,6 +1030,8 @@ module Rigor
 
         fallback_receiver = user_class_fallback_receiver(receiver_type, environment)
         return nil if fallback_receiver.nil?
+        return nil if declared_by_external_ancestor?(receiver_type, environment, context)
+        return nil if project_singleton_definer?(receiver_type, context)
 
         # Preserve the ORIGINAL receiver type as the `self` substitution so `Kernel#dup: () ->
         # self` and other `self`-returning methods route through Object's RBS while still
@@ -1055,6 +1056,92 @@ module Rigor
         )
       end
 
+      # Issue #2196 — a project class whose ancestry reaches a core or stdlib class before `Object` (`class FL <
+      # Array`) answers a name that class declares from that class, not from `Object` / `Kernel`: Ruby dispatches
+      # `select { … }` on an `FL` to `Array#select`, never to the private `Kernel#select` (`-> Array[String]`). The
+      # ancestor tiers decline such a name where they cannot type it (`RbsDispatch#returns_the_walked_ancestry?`),
+      # and the `Object` fallback then fabricated `Kernel#select`'s answer, so `fields.detect { |f| f.errors }` read
+      # `f` as `String`. The fallback declines the name instead, which leaves the call `Dynamic[top]`.
+      # {ExternalAncestorResolution.resolve} answers nil for a name only `Object`, `Kernel` or `BasicObject` declares,
+      # so `puts` and `raise` keep resolving.
+      def declared_by_external_ancestor?(receiver_type, environment, context)
+        return false unless receiver_type.is_a?(Type::Nominal)
+
+        scope = context.scope
+        return false if scope.nil?
+
+        memo = external_ancestor_memo(scope, environment)
+        key = [receiver_type.class_name, context.method_name]
+        return memo[key] if memo.key?(key)
+
+        memo[key] = !ExternalAncestorResolution.resolve(receiver_type.class_name, context.method_name, :instance,
+                                                        scope: scope, environment: environment,
+                                                        record_dependencies: false).nil?
+      end
+
+      # Issue #2284 — a class object whose singleton chain holds a project definer of the name (its own `def
+      # self.name`, one a project superclass wrote, an `extend`ed module's `def name`) answers from that definer,
+      # not from `Module#name` / `Class#…` on the `Singleton[Object]` fallback: Ruby's singleton ancestry puts
+      # every project entry ahead of `Class`. The fallback declines so the typer's singleton-body inference
+      # answers the definer's return, or `Dynamic` where the slot is contested and the def may not be the one
+      # that runs.
+      #
+      # The chain walk files the class edge of every entry it passes, so it runs only for a name some project file
+      # defines at all ({BlockCallTiming.project_defines_anywhere?}, which files the `defines:<name>` edge either way,
+      # #1459). Without it every class-body `private` / `attr_reader` call on a project class would depend on its
+      # whole ancestry. The by-name answer is memoised per discovery index; the edge is filed on every call.
+      def project_singleton_definer?(receiver_type, context)
+        return false unless receiver_type.is_a?(Type::Singleton)
+
+        scope = context.scope
+        return false if scope.nil?
+        return false unless project_defines_name?(scope, context.method_name)
+
+        !scope.singleton_def_through_ancestors(receiver_type.class_name, context.method_name).last.nil?
+      end
+
+      def project_defines_name?(scope, method_name)
+        memo = defines_name_memo(scope)
+        if memo.key?(method_name)
+          Analysis::DependencyRecorder.read_missing(:defines, method_name) if Analysis::DependencyRecorder.active?
+          return memo[method_name]
+        end
+
+        memo[method_name] = BlockCallTiming.project_defines_anywhere?(method_name, scope)
+      end
+
+      DEFINES_NAME_MEMO_KEY = RunScopedSlots.register(:__rigor_user_class_fallback_defines_name__)
+      private_constant :DEFINES_NAME_MEMO_KEY
+
+      # One slot per discovery index and environment, as {#external_ancestor_memo} keeps its own: the answer reads
+      # only the frozen discovery tables and the environment's `pre_eval:` patches.
+      def defines_name_memo(scope)
+        discovery = scope.discovery
+        environment = scope.environment
+        slot = Thread.current[DEFINES_NAME_MEMO_KEY]
+        unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
+          slot = [discovery, environment, {}]
+          Thread.current[DEFINES_NAME_MEMO_KEY] = slot
+        end
+        slot[2]
+      end
+
+      EXTERNAL_ANCESTOR_MEMO_KEY = RunScopedSlots.register(:__rigor_user_class_fallback_external_ancestor__)
+      private_constant :EXTERNAL_ANCESTOR_MEMO_KEY
+
+      # One slot per discovery index and environment, as `RbsDispatch#ancestor_memo_slot` keeps its own: the answer
+      # reads only the frozen discovery tables and the RBS environment, and its walk is withheld from dependency
+      # recording, so it may be served again for the same pair.
+      def external_ancestor_memo(scope, environment)
+        discovery = scope.discovery
+        slot = Thread.current[EXTERNAL_ANCESTOR_MEMO_KEY]
+        unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
+          slot = [discovery, environment, {}]
+          Thread.current[EXTERNAL_ANCESTOR_MEMO_KEY] = slot
+        end
+        slot[2]
+      end
+
       # True when the call node carries an explicit receiver that is not the literal `self`.
       # Such a call cannot legally dispatch to a private method, so the user-class fallback must
       # skip private signatures rather than return a confidently-wrong type. Returns false for
@@ -1099,12 +1186,14 @@ module Rigor
       #
       # `RbsDispatch` already distributes over a `Union` (and erases a `Difference` to its base, #533),
       # but it does so INSIDE one tier, so a member that needs a LOWER tier — a user class with no RBS,
-      # a discovered `def`, an opt-in gem — makes the whole union decline. That is the corpus shape:
-      # rigor-actionpack types `params[:k]` as `ActionController::Parameters | nil`, the `Parameters` arm
-      # resolves only through the user-class fallback, and so `params[:k].present?` / `#==` / `#blank?` /
-      # `#to_s` read opaque on every Rails app. Measured by toggling this file alone: the named-pair
-      # census drains 137 sites on redmine and 56 on mastodon, and `rigor check` reports the same
-      # diagnostics on both arms across eight survey targets.
+      # a discovered `def`, an opt-in gem — makes the whole union decline. That was the corpus shape before
+      # #2430: rigor-actionpack typed `params[:k]` as the bare `ActionController::Parameters | nil` union, the
+      # `Parameters` arm resolved only through the user-class fallback, and so `params[:k].present?` / `#==`
+      # / `#blank?` / `#to_s` read opaque on every Rails app. Measured by toggling this file alone: the
+      # named-pair census drained 137 sites on redmine and 56 on mastodon, and `rigor check` reported the
+      # same diagnostics on both arms across eight survey targets. The plugin now answers a `Dynamic`
+      # carrier, which this projection does not reach, so those off-chain calls read `Dynamic[top]` until
+      # the carrier is projected here too (#2448).
       #
       # **Why the bottom and not next to `RbsDispatch`.** Sitting here, the tier can only ever replace a
       # `Dynamic[top]` the typer was about to produce — the same ADR-5 argument {UniversalObjectDispatch}
@@ -1257,7 +1346,7 @@ module Rigor
         range_lift = range_new_lift(receiver_type.class_name, arg_types)
         return range_lift if range_lift
 
-        set_lift = set_new_lift(receiver_type.class_name, arg_types)
+        set_lift = set_new_lift(receiver_type.class_name, arg_types, context)
         return set_lift if set_lift
 
         hash_lift = hash_new_lift(receiver_type.class_name, arg_types, context&.call_node)
@@ -1307,8 +1396,8 @@ module Rigor
       # class is representable as the parent's singleton type — its singleton-method surface is
       # the parent's (plus whatever the block defines, which we do not statically track here),
       # so `Singleton[Parent]` lets downstream `klass.some_class_method` resolve. No parent →
-      # `singleton(Object)`. Anything else (dynamic parent, more than one positional, …) falls
-      # back to `Nominal[Class]` via the surrounding `meta_new` tail.
+      # `singleton(Object)` (or the block's anonymous class, #319 below). Anything else (dynamic parent, more
+      # than one positional, …) falls back to `Nominal[Class]` via the surrounding `meta_new` tail.
       # #319 — a `Class.new do ... end` with no parent is NOT `Object`: the block body is a class body, so the
       # class owns whatever that body defines. Answering `Singleton[Object]` handed the call site `Object`'s
       # zero-arity `new` and `Object`'s method surface, so an `initialize(bucket)` written right there produced
@@ -1613,19 +1702,10 @@ module Rigor
       # are given or the single argument is a `Tuple` whose every element is a `Constant[T]`.
       # Mirrors `SetFolding#fold_new` but lives here so the `:new` path in
       # `try_meta_introspection` can reach it before the RBS tier answers `Nominal[Set]`.
-      def set_new_lift(class_name, arg_types)
+      def set_new_lift(class_name, arg_types, context = nil)
         return nil unless class_name == "Set"
-        return Type::Combinator.constant_of(::Set.new) if arg_types.empty?
-        return nil if arg_types.size > 1
-
-        arg = arg_types.first
-        return nil unless arg.is_a?(Type::Tuple)
-        return nil unless arg.elements.all?(Type::Constant)
 
-        values = arg.elements.map(&:value)
-        Type::Combinator.constant_of(::Set.new(values))
-      rescue StandardError
-        nil
+        SetFolding.fold_new(arg_types, context&.call_node, context&.block_type)
       end
 
       # `Regexp.new(pattern)` / `Regexp.new(pattern, opts)` — folds to `Constant[Regexp]` when

data/lib/rigor/inference/module_function_state/spellings.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../../source/literals"
+
+module Rigor
+  module Inference
+    module ModuleFunctionState
+      # Issue #2209 — the `module_function` spellings other than the receiverless call that the deferred-ranges
+      # prescan ({ModuleFunctionState.prescan_deferred}) reads: `self.module_function(...)`, and
+      # `send(:module_function, ...)` or `__send__(:module_function, ...)` on no receiver or `self`, which Ruby runs
+      # as the receiverless call. `public_send` raises on a private method such as `module_function`, so it is not
+      # one.
+      #
+      # A literal name gives the `:singleton` row and a `def` argument the `:both` or `:singleton` row a receiverless
+      # call gives. The bare form, and an argument that is neither (`*names`, a local), gives an {ANY_ROW_NAME} row
+      # over the call: the prescan reads neither the toggle these spellings set nor such a name, so every singleton
+      # copy of the owner is uncertain (`DefinerResolution.module_function_row?`).
+      module Spellings
+        SEND_CALLS = %i[send __send__].freeze
+        private_constant :SEND_CALLS
+
+        module_function
+
+        # The arguments the spelling `node` passes `module_function`, or nil for any other call.
+        def arguments(node)
+          arguments = node.arguments&.arguments || []
+          return arguments if node.name == :module_function && node.receiver.is_a?(Prism::SelfNode)
+          return nil unless SEND_CALLS.include?(node.name)
+          return nil unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+          return nil unless Source::Literals.symbol_or_string(arguments.first) == :module_function
+
+          arguments.drop(1)
+        end
+
+        # Appends the rows of the spelling `node` with `arguments` ({.arguments}) to `ranges`, and prescans the rest
+        # as {ModuleFunctionState.prescan_deferred} prescans a receiverless call's.
+        def prescan(node, arguments, qualified_prefix, in_singleton_class, offsets, ranges)
+          owner = qualified_prefix.empty? ? nil : qualified_prefix.join("::")
+          call_span = [node.location.start_offset, node.location.end_offset]
+          any = arguments.empty?
+          arguments.each do |arg|
+            if arg.is_a?(Prism::DefNode)
+              kind = ScopeIndexer.def_singleton?(arg, qualified_prefix, in_singleton_class) ? :singleton : :both
+              ranges << [arg.location.start_offset, arg.location.end_offset, arg.name, kind, owner]
+            elsif (name = Source::Literals.symbol_or_string(arg))
+              ranges << [*call_span, name, :singleton, owner]
+            else
+              any = true
+              nested_prescan(arg, qualified_prefix, in_singleton_class, offsets, ranges)
+            end
+          end
+          ranges << [*call_span, ANY_ROW_NAME, :singleton, owner] if any
+          nested_prescan(node.block, qualified_prefix, in_singleton_class, offsets, ranges) if node.block
+        end
+
+        def nested_prescan(node, qualified_prefix, in_singleton_class, offsets, ranges)
+          ModuleFunctionState.prescan_deferred(node, qualified_prefix, in_singleton_class, offsets, ranges,
+                                               nested: true)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/module_function_state.rb

@@ -76,6 +76,17 @@ module Rigor
           (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
       end
 
+      # The `def` nodes a receiverless `public`, `private` or `protected` call takes as arguments (`private def x`,
+      # #2254). Ruby evaluates each one before the call, so it runs whenever the call's statement does. A named call
+      # with a symbol takes no def, and a call with a receiver is not read. A `module_function def` is not read here:
+      # its singleton copy is not modelled, so that gap stays as it was.
+      def visibility_call_defs(node)
+        return [] unless node.is_a?(Prism::CallNode) && node.receiver.nil?
+        return [] unless %i[public private protected].include?(node.name)
+
+        node.arguments&.arguments&.grep(Prism::DefNode) || []
+      end
+
       # The mode after `stmt`, a direct statement of a body, for the readers that walk the statements: `mode`
       # is `true`, `false` or `:uncertain` before it. A {.visibility_reset?} the statement runs ends the mode,
       # and one it may not run (`:maybe_off`, below {.prescan_deferred}) makes an on mode uncertain. A
@@ -318,10 +329,20 @@ module Rigor
         end
       end
 
+      # Issue #2209 — the row name of a deferred-ranges row that stands for every name of its owner
+      # ({Spellings}).
+      ANY_ROW_NAME = :*
+
+      # Issue #2209 — the deferred-ranges row names that make `method_name` a module function on their owner: its
+      # own and {ANY_ROW_NAME}.
+      def row_names(method_name) = [method_name.to_sym, ANY_ROW_NAME]
+
       # The prescan's arms for a call; true when the arm took the call and its subtree.
       def prescanned_call?(node, qualified_prefix, in_singleton_class, offsets, ranges, nested)
         if call?(node)
           prescan_call(node, qualified_prefix, in_singleton_class, offsets, ranges)
+        elsif (arguments = Spellings.arguments(node))
+          Spellings.prescan(node, arguments, qualified_prefix, in_singleton_class, offsets, ranges)
         elsif visibility_reset?(node)
           offsets << [node.location.start_offset, nested ? :maybe_off : :off]
         elsif ScopeIndexer.receiver_eval_call?(node) || (node.block && ScopeIndexer.meta_new_constant_rvalue?(node))
@@ -332,7 +353,6 @@ module Rigor
         true
       end
 
-      # The prescan's call arm.
       def prescan_call(node, qualified_prefix, in_singleton_class, offsets, ranges)
         if bare?(node)
           offsets << [node.location.start_offset, :on]
@@ -374,3 +394,5 @@ module Rigor
     end
   end
 end
+
+require_relative "module_function_state/spellings"

data/lib/rigor/inference/multi_target_binder.rb

@@ -12,7 +12,7 @@ module Rigor
     #
     # `Rigor::Inference::MultiTargetBinder` decomposes a tuple- or array-shaped right-hand side type
     # against a Prism multi-target tree and produces a `name -> Rigor::Type` binding map. The
-    # binder is shared between four surfaces:
+    # binder is shared between five surfaces:
     #
     # 1. `Rigor::Inference::StatementEvaluator#eval_multi_write` for the statement-level `a, b =
     #    rhs` form (`Prism::MultiWriteNode`).