rigortype 0.4.4 → 0.4.5

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

@@ -526,12 +526,60 @@ module Rigor
             registry = environment&.plugin_registry
             each_source_ancestor_candidate(scope, class_name) do |candidate|
               return nil if scope.discovered_method?(candidate, method_name, kind)
-              return candidate if ALLOWED_RBS_COMPLETE_ANCESTORS.include?(candidate) ||
-                                  registry&.rbs_complete_ancestor?(candidate)
+              next unless ALLOWED_RBS_COMPLETE_ANCESTORS.include?(candidate) ||
+                          registry&.rbs_complete_ancestor?(candidate)
+
+              return shadowed_in_ruby_order?(scope, class_name, kind, method_name, candidate) ? nil : candidate
             end
             nil
           end
 
+          # Issue #1572 — the walk above is breadth-first, so it reaches the superclass before a module an included
+          # module includes, which Ruby's order puts ahead of it (`class P < Rigor::Plugin::Base; include A` with `A`
+          # including `M` calls `M#prepare`, not `Base#prepare`), and it passes over RBS-known modules. True when the
+          # bridged `ancestor` is not what Ruby calls: on `class_name`'s {Scope::ResolutionChain} in Ruby's order, a
+          # project entry ahead of it records the name ({#project_records_name?}), an external entry ahead of it is a
+          # module RBS knows and declares the name in, or the chain does not hold it. An RBS-unknown external ahead is
+          # passed over, as the breadth-first walk always did. An unsettled chain withholds too: a mixin edge the
+          # tables cannot place (a receiver-form `Demo.include(M)` after the body, an edge in a conditional, a block or
+          # a hook) may put a definer ahead of the ancestor.
+          def shadowed_in_ruby_order?(scope, class_name, kind, method_name, ancestor)
+            chain = Scope::ResolutionChain.for(scope, class_name.to_s, kind, :methods)
+            return true if chain.unsettled?
+
+            entries = chain.entries
+            stop = entries.index do |entry|
+              entry.external? ? entry.candidates.include?(ancestor) : entry.name == ancestor
+            end
+            return true if stop.nil?
+
+            entries.first(stop).any? do |entry|
+              if entry.external?
+                rbs_declares_ahead?(scope, entry, method_name)
+              else
+                project_records_name?(scope, entry.name, method_name, entry.side)
+              end
+            end
+          end
+
+          # Whether the project entry `owner` holds the name on `kind`'s side. `discovered_methods` carries the
+          # `attr_*` and `define_method` rows project-wide, but at dispatch it has no row for a `def` in a module
+          # declared in another file, so a `def` is also asked of the project-wide def tables. ADR-46:
+          # `user_def_for` / `singleton_def_for` file the method edge, positive or negative, so a file that adds or
+          # removes the `def` on an entry ahead of the ancestor re-checks the call.
+          def project_records_name?(scope, owner, method_name, kind)
+            return true if scope.discovered_method?(owner, method_name, kind)
+
+            return !scope.singleton_def_for(owner, method_name).nil? if kind == :singleton
+
+            !scope.user_def_for(owner, method_name).nil?
+          end
+
+          def rbs_declares_ahead?(scope, entry, method_name)
+            entry.candidates.any? { |candidate| Rigor::Reflection.rbs_class_known?(candidate, scope: scope) } &&
+              !Scope::ResolutionChain::Relevance.external_lacks_on?(scope, entry.candidates, entry.side, method_name)
+          end
+
           # Issue #527 slice 1 — the RBS instance definition a Ruby-source class inherits from a CORE or
           # STDLIB ancestor, or nil. `Oj::EasyHash < Hash` answering `Dynamic[top]` to `has_key?` while
           # `{}.has_key?` folds was the largest single opacity family in the 2026-09-01 corpus sweep.

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
@@ -644,7 +661,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 +675,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

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,9 +124,26 @@ 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
       # copies the method in effect at the call (#1550), so a later def of the name redefines only the
       # instance method. This reading approximates that from the body's direct `statements`: it yields
@@ -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,24 @@ module Rigor
         end
       end
 
+      # 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 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 +345,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 +369,8 @@ 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

data/lib/rigor/inference/narrowing.rb

@@ -10,6 +10,7 @@ require_relative "../rbs_extended"
 require_relative "../analysis/fact_store"
 require_relative "../builtins/regex_refinement"
 require_relative "guard_rebinding"
+require_relative "intervening_ivar_reset"
 require_relative "key_presence_guard"
 require_relative "last_line"
 require_relative "operand_effects"
@@ -511,8 +512,9 @@ module Rigor
       # none of the condition shapes are recognised, both returned scopes equal the input
       # scope. The catalogue mirrors {.case_equality_target_class}: static class/module
       # constants narrow as `is_a?`; integer/float-endpoint ranges narrow to `Numeric`;
-      # string-endpoint ranges and regexp literals narrow to `String`; a `nil`, `true` or
-      # `false` literal narrows as its class does ({.when_condition_class}).
+      # string-endpoint ranges narrow to `String`; regexp literals narrow as
+      # {.regexp_case_equality_type} says; a `nil`, `true` or `false` literal narrows as its
+      # class does ({.when_condition_class}).
       def case_when_scopes(subject, conditions, scope)
         # C1 — `case x when /re/` runs `/re/ === x`, which sets the regex match-data globals
         # exactly as a successful `=~` does. Narrow `$~`/`$&`/`$1..$N` on the clause body (the
@@ -1797,9 +1799,13 @@ module Rigor
         # passes through unchanged (failing one pattern proves nothing about the string's shape).
         # A non-literal / unanchored / `\Z` / line-anchored / `//x` pattern falls through to no
         # narrowing.
+        #
+        # The refinement names a String, so it shares `=~`'s gate (#1955): a receiver that may be a Symbol, or an
+        # untyped one, is left as it is ({#refinable_operand?}).
         def analyse_whole_regex_match_predicate(node, scope)
           return nil unless node.receiver.is_a?(Prism::LocalVariableReadNode)
           return nil if node.arguments.nil? || node.arguments.arguments.size != 1
+          return nil unless refinable_operand?(node, scope)
 
           pattern = regex_operand_pattern(node.arguments.arguments.first, scope)
           return nil unless pattern.is_a?(RegexMatchPattern)
@@ -2636,10 +2642,10 @@ module Rigor
         #   iff the endpoints compare it. We conservatively narrow `x` to `Numeric` for
         #   integer-endpoint ranges and to `String` for string-endpoint ranges; other endpoint
         #   types fall through.
-        # - **Regexp literal receiver** (`/foo/ === x`): the match operator coerces `x` to a
-        #   String, so the truthy edge narrows `x` to `String`. The falsey edge keeps the entry
-        #   type unchanged because `Regexp#===` returns false for non-Strings AND for Strings
-        #   that simply do not match.
+        # - **Regexp literal receiver** (`/foo/ === x`): the truthy edge narrows `x` as
+        #   {#regexp_case_equality_type} says (its String and Symbol parts, #1955). The falsey edge
+        #   keeps the entry type unchanged because `Regexp#===` returns false for non-Strings AND
+        #   for Strings that simply do not match.
         #
         # Anything else — non-local LHS argument, dynamic receiver, custom `===` method — falls
         # through to the no-narrowing branch (nil), preserving the entry scope on both edges.
@@ -2703,6 +2709,9 @@ module Rigor
           if (class_name = lexical_class_name(receiver, scope))
             return class_predicate_scopes(scope, local_name, current, class_name, exact: false)
           end
+          if regexp_literal?(receiver)
+            return [scope.with_local(local_name, regexp_case_equality_type(current, scope)), scope]
+          end
 
           target_class = case_equality_target_class(receiver)
           return nil if target_class.nil?
@@ -2716,7 +2725,7 @@ module Rigor
         end
 
         # The class a `when` condition narrows the subject to, as `is_a?` would, or nil when the condition is no class
-        # test Rigor reads: a class or module constant, a range or regexp literal ({.case_equality_target_class}),
+        # test Rigor reads: a class or module constant, a range literal ({.case_equality_target_class}),
         # or (#1925) a `nil` / `true` / `false` literal. `nil === x` runs `NilClass#===`, which holds only for `nil`
         # itself whatever the subject's class defines, and `nil` is `NilClass`'s only instance, so `when nil` is
         # `when NilClass`; `true` and `false` likewise.
@@ -2733,8 +2742,9 @@ module Rigor
         # Maps a case-equality literal receiver to the class whose membership is implied by the
         # truthy edge. `Prism::ParenthesesNode` wrappers are transparently unwrapped (`(1..10)
         # === x` is parsed with the range inside parentheses).  Range literals: integer
-        # endpoints → `Numeric`; string endpoints → `String`. Regexp literals → `String`. Other
-        # shapes return nil so the caller falls through.
+        # endpoints → `Numeric`; string endpoints → `String`. Regexp literals → `String`, read only
+        # as the class a dead `when` arm names: their narrowing is {#regexp_case_equality_type}'s,
+        # which the callers consult first. Other shapes return nil so the caller falls through.
         def case_equality_target_class(receiver)
           receiver = unwrap_parens(receiver)
           case receiver
@@ -2743,6 +2753,33 @@ module Rigor
           end
         end
 
+        def regexp_literal?(node)
+          case unwrap_parens(node)
+          when Prism::RegularExpressionNode, Prism::InterpolatedRegularExpressionNode then true
+          else false
+          end
+        end
+
+        # Issue #1955 — the subject on the match edge of `/re/ === x` (and of `case x when /re/`). `Regexp#===`
+        # matches a String, a Symbol by its name, and an object that converts with `to_str`, and answers false for
+        # anything else. Each member narrows to its String and Symbol parts: a `String | nil` subject reads `String`, a
+        # Symbol one stays `Symbol`. The `to_str` conversion is not modelled, so a member that defines `to_str` and is
+        # neither drops out of the edge. A `Dynamic` member is left as it is, since it may be a Symbol at run time. The
+        # no-match edge keeps the entry type: a String that does not match reaches it too.
+        def regexp_case_equality_type(current, scope)
+          members = current.is_a?(Type::Union) ? current.members : [current]
+          Type::Combinator.union(*members.map { |member| regexp_case_equality_member(member, scope) })
+        end
+
+        def regexp_case_equality_member(member, scope)
+          return member if member.is_a?(Type::Dynamic)
+
+          parts = %w[String Symbol].map do |class_name|
+            narrow_class(member, class_name, exact: false, environment: scope.environment, scope: scope)
+          end
+          Type::Combinator.union(*parts)
+        end
+
         def unwrap_parens(node)
           while node.is_a?(Prism::ParenthesesNode) && node.body.is_a?(Prism::StatementsNode) &&
                 node.body.body.size == 1
@@ -2971,6 +3008,10 @@ module Rigor
             return integer_literal_when_result(current, int_literal, falsey_acc)
           end
 
+          if regexp_literal?(condition)
+            return { truthy: regexp_case_equality_type(current, scope), falsey: falsey_acc, fully_narrowable: true }
+          end
+
           target = when_condition_class(condition, scope)
           return class_when_result(scope, current, target, falsey_acc) if target
 
@@ -3793,9 +3834,12 @@ module Rigor
         # that edge, so a `$_` the earlier operand narrowed is forgotten when the operand may set it
         # (`gets && log(items.each { gets })`), before the operand's own edges narrow it again.
         # Issue #1429 — likewise a guard's narrowing of a global or constant the operand may rebind
-        # (`$sep && reset_sep && $sep.length`).
+        # (`$sep && reset_sep && $sep.length`). Issue #1963 — and an instance variable's narrowing an implicit-self
+        # or `self.` call in the operand may write ({InterveningIvarReset.after_operand}): `@x.nil? && reset!` does
+        # not leave `@x` `nil` when `reset!` assigns it.
         def operand_edges(node, edge_scope)
           edge_scope = LastLine.forget_if_set(edge_scope, node)
+          edge_scope = InterveningIvarReset.after_operand(node, edge_scope)
           if edge_scope.guard_narrowed? && GuardRebinding.may_rebind?(node, edge_scope)
             edge_scope = edge_scope.forget_guard_narrowings
           end