rigortype 0.4.4 → 0.4.6

data/lib/rigor/inference/method_dispatcher.rb

@@ -220,7 +220,8 @@ module Rigor
         # `call.undefined-method`.
         patched_result =
           unless skip_project_patched
-            try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment)
+            try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment,
+                                       call_node: call_node, scope: scope)
           end
         if patched_result
           scope&.record_dynamic_origin(call_node, DynamicOrigin::EXTERNAL_GEM_WITHOUT_RBS)
@@ -258,6 +259,22 @@ module Rigor
           return discovered_result
         end
 
+        # Issue #1708 — a `pre_eval:` patch on one of the receiver's ancestors (`class Object; def zz`,
+        # `module Enumerable; def sum_by`). Below the RBS tier, whose decline means no nearer RBS declares the
+        # method, and below the tiers that answer the receiver's own patch or a gem catalogue entry. A nearer
+        # `def` in the project's source (on an RBS-known receiver, which the discovered-method tier leaves to
+        # user-method inference) stops the walk: see {#project_source_defines?}. That probe reads the scope's def
+        # index, so a single-file scope (`type-of`, `annotate`, an LSP buffer) cannot see a `def` in another file.
+        ancestor_patched =
+          if !skip_project_patched && scope
+            try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment,
+                                       call_node: call_node, scope: scope, through_ancestors: true)
+          end
+        if ancestor_patched
+          scope&.record_dynamic_origin(call_node, DynamicOrigin::EXTERNAL_GEM_WITHOUT_RBS)
+          return ancestor_patched
+        end
+
         # ADR-5 robustness — synthesized-stub-type tier. When the receiver is a type Rigor
         # invented to make an otherwise-unbuildable project signature resolve (a
         # missing-namespace module, or a stub for a referenced-but-undeclared type like an
@@ -518,10 +535,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
@@ -644,7 +660,13 @@ module Rigor
       # `def to_url; "hello"; end` patched onto `String` now resolves `s.to_url` to
       # `Dynamic[Nominal[String]]` instead of the pre-3a `Dynamic[Top]`. Falls back to
       # `Dynamic[Top]` when the heuristic declined (non-literal tail expression).
-      def try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment)
+      #
+      # `through_ancestors:` (issue #1708), with a scope, searches the receiver's ancestors as well, through
+      # {ProjectPatchedMethods#lookup_through_ancestors}, stopping at a nearer project-source `def`. A private or
+      # protected patch Ruby would not let the call reach ({ProjectPatchedMethods#callable?}) answers nothing, so
+      # `1.kp` on `module Kernel; private def kp` reads as the undefined call it is.
+      def try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment, # rubocop:disable Metrics/ParameterLists
+                                     call_node: nil, scope: nil, through_ancestors: false)
         registry = environment&.project_patched_methods
         return nil if registry.nil? || registry.empty?
 
@@ -652,14 +674,55 @@ module Rigor
         return nil if class_name.nil?
 
         kind = receiver_type.is_a?(Type::Singleton) ? :singleton : :instance
-        entry = registry.lookup(class_name: class_name, method_name: method_name, kind: kind)
+        entry = project_patched_entry(registry, class_name, method_name, kind, environment,
+                                      scope: scope, through_ancestors: through_ancestors)
         return nil if entry.nil?
+
+        verdict = registry.callable?(entry, explicit: explicit_non_self_receiver?(call_node),
+                                            self_type: scope ? scope.self_type : :unknown,
+                                            rbs_loader: environment.rbs_loader)
+        return nil if verdict == false
+        return Type::Combinator.untyped if verdict.nil?
         return Type::Combinator.dynamic(entry.return_type) if entry.return_type
 
         aliased = project_patched_alias_target(entry, receiver_type, arg_types, block_type, environment)
         aliased ? Type::Combinator.dynamic(aliased) : Type::Combinator.untyped
       end
 
+      def project_patched_entry(registry, class_name, method_name, kind, environment, scope:, through_ancestors:)
+        return registry.lookup(class_name: class_name, method_name: method_name, kind: kind) unless through_ancestors
+
+        registry.lookup_through_ancestors(
+          class_name: class_name, method_name: method_name, kind: kind, rbs_loader: environment.rbs_loader,
+          source_defines: ->(owner, side) { project_source_defines?(scope, owner, method_name, side) }
+        )
+      end
+
+      # Issue #1708 — does the project's own source define `method_name` on `owner` (`side` as the ancestor walk
+      # reaches it), or on a module the project prepends to or includes into it? Ruby runs that `def` ahead of a
+      # patch on a farther ancestor: `class Integer; def nn = "s"` beats `class Object; def nn = nil` in a
+      # `pre_eval:` file. The owner's level of its {Scope::ResolutionChain} (its prepends, itself, its includes
+      # and their own mixins, or a class object's singleton and its extends) holds those definers; whether one
+      # of them defines the name does not depend on their order, so the chain is searched without settling it.
+      def project_source_defines?(scope, owner, method_name, side)
+        return false unless scope.known_user_class?(owner)
+
+        chain = Scope::ResolutionChain.for(scope, owner, side, :methods)
+        own_level_end = chain.level_starts[1] || chain.entries.size
+        found = chain.search(scope, 0, own_level_end) do |entry|
+          !entry.external? && source_def?(scope, entry.name, method_name, entry.side)
+        end
+        !found.nil?
+      end
+
+      def source_def?(scope, owner, method_name, side)
+        if side == :singleton
+          scope.discovered_method?(owner, method_name, :singleton) || !scope.singleton_def_for(owner, method_name).nil?
+        else
+          scope.discovered_method?(owner, method_name, :instance) || !scope.user_def_for(owner, method_name).nil?
+        end
+      end
+
       # Issue #1702 — an alias in a `pre_eval:` patch whose old name no earlier patch binding defines
       # (`alias old_plus +` on Integer, or `alias_method :orig_succ, :succ` ahead of the patch's own `def succ`)
       # names the method the class had before the patch, so it answers what that method answers for the same
@@ -967,6 +1030,7 @@ 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)
 
         # 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
@@ -991,6 +1055,45 @@ 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
+
+      EXTERNAL_ANCESTOR_MEMO_KEY = :__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
@@ -1193,7 +1296,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)
@@ -1549,19 +1652,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

@@ -9,24 +9,36 @@ module Rigor
     # The one home for what a receiverless `module_function` call does to the methods around it
     # ([#1507](https://github.com/rigortype/rigor/issues/1507),
     # [#1197](https://github.com/rigortype/rigor/issues/1197)). Four readers used to compute it in four
-    # places. They disagree with each other and, in places, with Ruby. Each entry point below reproduces
-    # one reader's answer exactly: this module gives the readings one place to live, and does not yet make
-    # them agree. A change to one reading lands here, beside the other three. An example is the reset a bare
-    # `public`, `private` or `protected` makes.
+    # places, and the method-visibility table reads it too. They disagree with each other and, in places, with
+    # Ruby. Each entry point below reproduces one reader's answer exactly: this module gives the readings one
+    # place to live, and does not yet make them agree. A change to one reading lands here, beside the others.
+    #
+    # In Ruby a bare `module_function` call turns the body's module_function mode on, and a later bare
+    # `public`, `private` or `protected` ({.visibility_reset?}) turns it off again (#1968). A named call
+    # (`public :x`, `private def y`) leaves the mode alone, and each `module` body starts with it off. A reset
+    # written in the body's own statements, or in a plain `begin` or `ensure` there, runs. One nested anywhere
+    # else (control flow, a block, a `rescue` clause, an argument) may not, so the mode after it is uncertain.
+    # A reset in a nested `class`, `module`, `class <<` or `def` body, a `*_eval` / `*_exec` block or a
+    # class-creating block (`Class.new do`, `Struct.new do`, ...) belongs to another scope and does not count.
     #
     # - The singleton def-node table (`ScopeIndexer#walk_singleton_body`) reads
     #   {.each_singleton_sibling} and {.each_singleton_copy}. A bare call covers the later direct
-    #   statements of its own body and is never reset.
+    #   statements of its own body, up to a reset; after an uncertain one the copy is possible.
     # - The deferred ranges (`ScopeIndexer#walk_deferred_body`) read {.prescan_deferred} and
-    #   {.deferred_module_function?}. A bare call covers every later def by offset, and a call inside
-    #   control flow or a block counts.
+    #   {.deferred_module_function?}. A bare call covers every later def by offset, up to a later reset,
+    #   and a call inside control flow or a block counts. An uncertain reset changes nothing here.
     # - The extends table (`ScopeIndexer#record_extend_call`) reads {.extends_self?}. A bare call covers
-    #   every instance def of the module, in any order.
+    #   every instance def of the module, in any order, and is never reset.
     # - sig-gen (`SigGen::Generator#walk_statements`) reads {.each_sig_gen_statement} and
     #   {.sig_gen_module_function?}. A bare call covers the later statements of its own statement list and
-    #   what nests in them.
+    #   what nests in them, up to a reset; after an uncertain one {.sig_gen_uncertain?} says so.
+    # - The method-visibility table (`ScopeIndexer#walk_method_visibilities`) reads {.instance_visibility}. It
+    #   applies a `module_function` call as it applies a `private` one, bare or named: the call makes the instance
+    #   copy private (#1569), and a later bare `public`, `private` or `protected` sets the running default as it
+    #   would anyway, so the reset needs no reading of its own. A call or reset that may not run leaves the slots
+    #   after it contested, as any visibility call there does.
     #
-    # A fifth reader does not come here yet: `rigor-activerecord`'s `ModelDiscoverer#table_name_decorators`
+    # Another reader does not come here yet: `rigor-activerecord`'s `ModelDiscoverer#table_name_decorators`
     # (`plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_discoverer.rb`) reads a module body's
     # direct statements for its table-name readers. It also accepts `self.module_function`, and there a bare
     # call covers the instance methods written before it as well as after it, while a named call takes only a
@@ -47,23 +59,60 @@ module Rigor
         node.name == :module_function && node.receiver.nil?
       end
 
+      # The visibility a `module_function` call gives the instance method of each name it covers, bare or named:
+      # Ruby makes the instance copy private and adds a public singleton copy, which the instance-side
+      # method-visibility table does not hold (#1569).
+      def instance_visibility = :private
+
       # The toggle form: a `module_function` call with no arguments.
       def bare?(node)
         node.arguments.nil? || node.arguments.arguments.empty?
       end
 
+      # A bare `public`, `private` or `protected` call, receiverless or on `self`: Ruby ends the module_function
+      # mode there (#1968). A call with arguments sets the named methods' visibility and leaves the mode alone.
+      def visibility_reset?(node)
+        %i[public private protected].include?(node.name) && bare?(node) &&
+          (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
+      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
+      # `module_function` nested in the statement is not read here, as before. `nested` says the statement
+      # itself may not run, so every reset in it may not either.
+      def mode_after(mode, stmt, nested: false)
+        return mode unless mode
+
+        events = []
+        prescan_deferred(stmt, EMPTY_PREFIX, false, events, [], nested: nested)
+        events.sort_by(&:first).each do |_offset, event|
+          case event
+          when :off then mode = false
+          when :maybe_off then mode = :uncertain if mode == true
+          end
+        end
+        mode
+      end
+
+      # The owner prefix {.mode_after} hands the prescan, which records no row a reset needs.
+      EMPTY_PREFIX = [].freeze
+
       # The singleton def-node table's reading, over one class-ish body's direct statements in source
       # order. `ScopeIndexer#statements_of` builds that list, folding a body-level `rescue`, `else` or
       # `ensure` clause into it. Yields `stmt, module_function_on, named_call` for every statement except a
       # bare call:
       #
-      # - `module_function_on` says whether a bare call precedes the statement. The toggle never switches
-      #   off, although a later bare `public`, `private` or `protected` resets it in Ruby.
+      # - `module_function_on` is `true` when a bare call precedes the statement with no reset between them,
+      #   `:uncertain` when a reset that may not run is between them ({.mode_after}), and `false` otherwise.
       # - `named_call` is true for a named call (`module_function :a` or `module_function def x`), which
       #   {.each_singleton_copy} resolves; the caller records nothing else for it.
       #
-      # A call nested in control flow or a block is not seen.
-      def each_singleton_sibling(statements)
+      # A `module_function` call nested in control flow or a block is not seen. `conditional` lists the
+      # statements of a body-level `rescue` or `else` clause ({.conditional_clause_statements}), which may not
+      # run, so a reset there makes the mode uncertain rather than ending it.
+      def each_singleton_sibling(statements, conditional = [])
+        conditional = Set.new(conditional).compare_by_identity
         module_function_on = false
         statements.each do |stmt|
           if stmt.is_a?(Prism::CallNode) && call?(stmt)
@@ -75,7 +124,24 @@ module Rigor
             next
           end
           yield stmt, module_function_on, false
+          module_function_on = mode_after(module_function_on, stmt, nested: conditional.include?(stmt))
+        end
+      end
+
+      # The statements of a body-level `rescue` or `else` clause, which `ScopeIndexer#statements_of` folds into
+      # the body's direct statements although they run only on an exception, or only without one. An `ensure`
+      # clause runs either way and is not listed.
+      def conditional_clause_statements(body)
+        return [] unless body.is_a?(Prism::BeginNode)
+
+        statements = []
+        clause = body.rescue_clause
+        while clause
+          statements.concat(ScopeIndexer.statements_of(clause.statements))
+          clause = clause.subsequent
         end
+        statements.concat(ScopeIndexer.statements_of(body.else_clause.statements)) if body.else_clause
+        statements
       end
 
       # The defs a named call copies onto the module's singleton, for the singleton def-node table. Ruby
@@ -121,10 +187,11 @@ module Rigor
         alias_method define_method attr attr_reader attr_writer attr_accessor remove_method undef_method
       ].freeze
 
-      # The deferred-ranges reading, over one class-ish body's subtree. Appends to `offsets` the start of
-      # every bare call; each def that starts after one is a module function
-      # ({.deferred_module_function?}). Appends to `ranges` one row per named call, in the table's
-      # `[start, end, name, kind, owner]` shape:
+      # The deferred-ranges reading, over one class-ish body's subtree. Appends to `offsets` an
+      # `[offset, :on]` event for the start of every bare call, and for every {.visibility_reset?} an
+      # `[offset, :off]` event where it runs or a `[offset, :maybe_off]` one where it may not: `nested` is true
+      # once the walk has left the body's statements, a plain `begin` and an `ensure`. Appends to `ranges` one
+      # row per named call, in the table's `[start, end, name, kind, owner]` shape:
       #
       # - a `:name` argument gives a `:singleton` row over the call itself, because the copy happens at
       #   the call and not at the def;
@@ -134,33 +201,36 @@ module Rigor
       # The prescan looks through control flow and blocks, because a call that ran there still flips the
       # later defs. It stops at a nested class, module, `class <<` or def body, where the call targets
       # another module. It skips an `END` body, which runs after every def, and a `*_eval` / `*_exec`
-      # block, whose self is the receiver's module; that block gets its own prescan as a body. Nothing
-      # resets it.
+      # block, whose self is the receiver's module, and a class-creating block (`Class.new do`, `Struct.new do`,
+      # `Data.define do`, `Module.new do`), whose self is the new class; such a block gets its own prescan as a
+      # body where the walk opens one.
       #
       # `qualified_prefix` names the owner, and `in_singleton_class` says whether the body is a
       # `class <<` body; both feed `ScopeIndexer.def_singleton?`.
-      def prescan_deferred(node, qualified_prefix, in_singleton_class, offsets, ranges)
+      def prescan_deferred(node, qualified_prefix, in_singleton_class, offsets, ranges, nested: false)
         return unless node.is_a?(Prism::Node)
         return if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode) ||
                   node.is_a?(Prism::SingletonClassNode) || node.is_a?(Prism::DefNode) ||
                   node.is_a?(Prism::PostExecutionNode)
+        return if node.is_a?(Prism::CallNode) &&
+                  prescanned_call?(node, qualified_prefix, in_singleton_class, offsets, ranges, nested)
 
-        if node.is_a?(Prism::CallNode)
-          return prescan_call(node, qualified_prefix, in_singleton_class, offsets, ranges) if call?(node)
-          if ScopeIndexer.receiver_eval_call?(node)
-            return prescan_eval_call(node, qualified_prefix, in_singleton_class, offsets, ranges)
-          end
-        end
-
+        nested ||= !RUN_IN_PLACE.include?(node.class)
         node.rigor_each_child do |child|
-          prescan_deferred(child, qualified_prefix, in_singleton_class, offsets, ranges)
+          prescan_deferred(child, qualified_prefix, in_singleton_class, offsets, ranges, nested: nested)
         end
       end
 
-      # Whether the deferred-ranges reading makes a def starting at `start` a module function: a bare call
-      # starts before it, at any depth the prescan entered.
+      # The nodes whose statements run where they are written, so a reset there runs ({.prescan_deferred}).
+      RUN_IN_PLACE = [Prism::StatementsNode, Prism::BeginNode, Prism::EnsureNode].freeze
+
+      # Whether the deferred-ranges reading makes a def starting at `start` a module function: the last
+      # `:on` or `:off` event {.prescan_deferred} recorded before it, at any depth the prescan entered, is
+      # `:on`. A `:maybe_off` leaves the answer as it was: the row stays `:both`, the reading that counts the
+      # def as run on the singleton side too, since the table has no possible row for it.
       def deferred_module_function?(offsets, start)
-        offsets.any? { |offset| offset < start }
+        last = offsets.select { |offset, event| offset < start && event != :maybe_off }.max_by(&:first)
+        last ? last[1] == :on : false
       end
 
       # The extends table's reading. A bare call makes the module extend itself, so every instance def the
@@ -174,10 +244,12 @@ module Rigor
       end
 
       # sig-gen's reading, over one statement list. Yields every statement except a bare call, with
-      # whether a bare call came before it in this list or `active` was already true on entry. The
+      # whether a bare call came before it in this list or `active` was already on at entry: `true`, `false`
+      # or `:uncertain` after a reset that may not run ({.mode_after}). The
       # generator passes the enclosing list's answer into an `if`, a block or a `begin`, but not into a
       # nested class, module or `class << self`. A bare call in a nested list covers only that list's
-      # later statements. Nothing resets it, and a named call is not a directive at all.
+      # later statements. A reset ends it for the statements after it, and a named call is not a directive at
+      # all.
       def each_sig_gen_statement(statements, active)
         statements.each do |stmt|
           if sig_gen_directive?(stmt)
@@ -185,6 +257,7 @@ module Rigor
             next
           end
           yield stmt, active
+          active = mode_after(active, stmt)
         end
       end
 
@@ -196,7 +269,13 @@ module Rigor
       # Whether sig-gen renders a def as `def self?.name`: an instance-side def under an active directive,
       # in a class or a module alike. `kind` is `:singleton` for `def self.x` and a `class << self` body.
       def sig_gen_module_function?(active, kind)
-        active && kind == :instance
+        active == true && kind == :instance
+      end
+
+      # Whether sig-gen cannot tell a def's kind: an instance-side def after a reset that may not run, which
+      # is a module function only if the reset did not run.
+      def sig_gen_uncertain?(active, kind)
+        active == :uncertain && kind == :instance
       end
 
       # Yields each instance-method name `node` may rebind on the module whose body holds it, or
@@ -239,10 +318,34 @@ 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))
+          prescan_eval_call(node, qualified_prefix, in_singleton_class, offsets, ranges)
+        else
+          return false
+        end
+        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
+          offsets << [node.location.start_offset, :on]
         else
           owner = qualified_prefix.empty? ? nil : qualified_prefix.join("::")
           node.arguments&.arguments&.each do |arg|
@@ -252,20 +355,22 @@ module Rigor
             elsif (name = symbol_argument_name(arg))
               ranges << [node.location.start_offset, node.location.end_offset, name, :singleton, owner]
             else
-              prescan_deferred(arg, qualified_prefix, in_singleton_class, offsets, ranges)
+              prescan_deferred(arg, qualified_prefix, in_singleton_class, offsets, ranges, nested: true)
             end
           end
         end
         return unless node.block
 
-        prescan_deferred(node.block, qualified_prefix, in_singleton_class, offsets, ranges)
+        prescan_deferred(node.block, qualified_prefix, in_singleton_class, offsets, ranges, nested: true)
       end
 
       # The prescan's eval arm: only the call's receiver and arguments keep this module's context.
       def prescan_eval_call(node, qualified_prefix, in_singleton_class, offsets, ranges)
-        prescan_deferred(node.receiver, qualified_prefix, in_singleton_class, offsets, ranges) if node.receiver
+        if node.receiver
+          prescan_deferred(node.receiver, qualified_prefix, in_singleton_class, offsets, ranges, nested: true)
+        end
         node.arguments&.arguments&.each do |arg|
-          prescan_deferred(arg, qualified_prefix, in_singleton_class, offsets, ranges)
+          prescan_deferred(arg, qualified_prefix, in_singleton_class, offsets, ranges, nested: true)
         end
       end
 
@@ -274,8 +379,10 @@ module Rigor
         Source::Literals.symbol_or_string(arg)
       end
 
-      private_class_method :prescan_call, :prescan_eval_call, :symbol_argument_name, :each_rebound_name,
-                           :each_own_rebound_name, :each_rebinding_call_name
+      private_class_method :prescan_call, :prescanned_call?, :prescan_eval_call, :symbol_argument_name,
+                           :each_rebound_name, :each_own_rebound_name, :each_rebinding_call_name
     end
   end
 end
+
+require_relative "module_function_state/spellings"

data/lib/rigor/inference/mutation_widening.rb

@@ -7,6 +7,7 @@ require_relative "../source/node_children"
 require_relative "content_join"
 require_relative "hash_lookup_mutation"
 require_relative "mutation_rejoin"
+require_relative "deep_erasure"
 require_relative "receiver_alias"
 require_relative "refinement_mutation"
 require_relative "rewrite_mutation"
@@ -200,12 +201,15 @@ module Rigor
       # `Prism::BlockNode`s — each block is processed by its own `eval_call`.
       def widen_after_block(call_node:, outer_scope:)
         block = call_node.block
+        return DeepErasure.widen_symbol_proc(call_node, outer_scope) if DeepErasure.symbol_proc_mutation?(block)
         return outer_scope unless block.is_a?(Prism::BlockNode)
 
         body = block.body
         return outer_scope if body.nil?
 
-        walk_for_outer_mutations(body, outer_scope)
+        scope = walk_for_outer_mutations(body, outer_scope)
+        names = DeepErasure.parameter_names(block.parameters)
+        DeepErasure.widen_element_aliases(call_node.receiver, block.body, names, scope)
       end
 
       def walk_for_outer_mutations(node, scope)
@@ -257,7 +261,6 @@ module Rigor
                                                 Prism::ClassVariableReadNode => %i[cvar with_cvar],
                                                 Prism::GlobalVariableReadNode => %i[global with_global]
                                               })
-      private_constant :ALIAS_ACCESSORS
 
       def widen_alias_read(method_name, read, scope, values: :widen, arg_types: NO_ARG_TYPES)
         getter, builder = ALIAS_ACCESSORS[read.class]