rigortype 0.4.4 → 0.4.5

data/lib/rigor/effects/signature_sources.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../rooted_glob"
+
 module Rigor
   module Effects
     # Everything an effect envelope may be written in, as `[buffer name, RBS source]` pairs
@@ -55,7 +57,7 @@ module Rigor
       # @param signature_paths — the configured roots; empty / nil takes the default.
       # @param virtual_rbs — the loader's virtual entries.
       def collect(signature_paths:, virtual_rbs: nil)
-        files = roots(signature_paths).flat_map { |root| Dir.glob(File.join(root.to_s, "**", "*.rbs")).sort }
+        files = roots(signature_paths).flat_map { |root| RootedGlob.glob(root, "**/*.rbs").sort }
         sources = files.filter_map do |path|
           [path, File.read(path)]
         rescue StandardError

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -3,6 +3,7 @@
 require "yaml"
 
 require_relative "../config_path"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -91,8 +92,8 @@ module Rigor
         # all (`Bundler::Source::Path#path` is the user's own `path:` directory, used in place), so there is
         # no bundle-relative location to walk. A `path:`-sourced gem's `sig/` is only reachable by adding it
         # directly to the project's `signature_paths:` — which already works today and needs no discovery.
-        all = (Dir.glob(resolved.join("ruby", "*", "gems", "*", "sig")) +
-               Dir.glob(resolved.join("ruby", "*", "bundler", "gems", "*", "sig"))).map { |d| Pathname.new(d) }
+        all = (RootedGlob.glob(resolved, "ruby/*/gems/*/sig") +
+               RootedGlob.glob(resolved, "ruby/*/bundler/gems/*/sig")).map { |d| Pathname.new(d) }
         filtered = all.reject { |sig_dir| skip_gems.include?(gem_name_from_sig_path(sig_dir)) }
         return filtered if locked_gems.nil? || locked_gems.empty?
 

data/lib/rigor/environment/gated_signature_guard.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rbs"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -15,7 +16,7 @@ module Rigor
       # @param dir — the vendored directory (Pathname).
       # @return the absolute-less names (`"Prime::PseudoPrimeGenerator"`) of every class and module it declares.
       def type_names(dir)
-        Dir.glob(File.join(dir.to_s, "*.rbs")).flat_map do |file|
+        RootedGlob.glob(dir, "*.rbs").flat_map do |file|
           _, _, decls = RBS::Parser.parse_signature(File.read(file))
           names(decls, nil)
         rescue RBS::BaseError, SystemCallError

data/lib/rigor/environment/gated_signature_plan.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rbs"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -132,7 +133,7 @@ module Rigor
       end
 
       def signature_files(roots)
-        roots.flat_map { |root| Dir.glob(File.join(root.to_s, "*.rbs")).sort }
+        roots.flat_map { |root| RootedGlob.glob(root, "*.rbs").sort }
       end
 
       def shell_buffer

data/lib/rigor/environment/installed_gem_set.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "lockfile_resolver"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -47,7 +48,7 @@ module Rigor
         base = Pathname.new(bundle_path)
         return {} unless base.directory?
 
-        Dir.glob(base.join("ruby", "*", "gems", "*")).each_with_object({}) do |dir, acc|
+        RootedGlob.glob(base, "ruby/*/gems/*").each_with_object({}) do |dir, acc|
           name, version, platform = split_install_dirname(File.basename(dir))
           next unless name
 

data/lib/rigor/environment/missing_gem_constant_index.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -71,7 +72,7 @@ module Rigor
         base = Pathname.new(bundle_path)
         return {} unless base.directory?
 
-        Dir.glob(base.join("ruby", "*", "gems", "*")).each_with_object({}) do |dir, acc|
+        RootedGlob.glob(base, "ruby/*/gems/*").each_with_object({}) do |dir, acc|
           acc[File.basename(dir)] ||= dir
         end
       end
@@ -114,7 +115,7 @@ module Rigor
         base = Pathname.new(bundle_path)
         return {} unless base.directory?
 
-        Dir.glob(base.join("ruby", "*", "bundler", "gems", "*")).each_with_object({}) do |dir, acc|
+        RootedGlob.glob(base, "ruby/*/bundler/gems/*").each_with_object({}) do |dir, acc|
           name = gemspec_gem_name(dir)
           acc[name] ||= dir if name
         end
@@ -124,7 +125,7 @@ module Rigor
       # exactly one. Bundler requires a git-sourced gem to ship one, so "not exactly one" means this is not
       # the shape we think it is — and a guess from the directory basename is what this exists to avoid.
       def gemspec_gem_name(dir)
-        specs = Dir.glob(File.join(dir, "*.gemspec"))
+        specs = RootedGlob.glob(dir, "*.gemspec")
         return nil unless specs.size == 1
 
         File.basename(specs.first, ".gemspec")

data/lib/rigor/environment/rbs_loader.rb

@@ -10,6 +10,7 @@ require_relative "member_consistency"
 require_relative "required_features"
 require_relative "gated_signature_guard"
 require_relative "gated_signature_plan"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -549,7 +550,7 @@ module Rigor
             path = Pathname(path) unless path.is_a?(Pathname)
             next [] unless path.directory?
 
-            Dir.glob(path.join("**", "*.rbs")).map { |p| File.expand_path(p) }
+            RootedGlob.glob(path, "**/*.rbs").map { |p| File.expand_path(p) }
           end.to_set
         end
 
@@ -1916,6 +1917,25 @@ module Rigor
         (@state[:definition_build_failures] || []).dup.freeze
       end
 
+      # Issue #1929 — re-ask for `class_name`'s definition on behalf of a PREVIOUS run's analysis, which
+      # demanded it and found it failing. An `--incremental` recheck replays that run's failures, and one
+      # whose conflicting buffer is a file the recheck re-synthesized cannot be replayed as it stands (the
+      # edit may have fixed it), while the file that demanded the class may sit outside the recheck's
+      # closure and never ask again. Re-asking here re-derives the answer over the current signatures: a
+      # class that still fails is reported with its current tuple, one that now builds is not.
+      #
+      # A real demand, not {#during_internal_demand}: it stands in for the analysis's own, which is what
+      # #696 binds the reported set to. Both sides are asked, since the replayed tuple does not record which
+      # side the analysis demanded ({#report_definition_build_failure} builds both anyway).
+      #
+      # @return the class's current tuple, or nil when it now builds.
+      def redemand_definition(class_name)
+        key = class_name.to_s.delete_prefix("::")
+        instance_definition(key)
+        singleton_definition(key)
+        definition_build_failures.find { |failure| failure.first == key }
+      end
+
       # Virtual (inline-synthesized) contributions dropped by the collision quarantine
       # ({.resolve_quarantining_virtual_collisions}): buffer names absent from the built env even though the
       # entry's content is non-empty and parses (a parse failure is the synthesizer's own WD6 skip, reported

data/lib/rigor/inference/block_call_timing.rb

@@ -72,6 +72,12 @@ module Rigor
 
       module_function
 
+      # Whether `call_node` is spelled to reach the private `Kernel#loop` (see {.loop_may_complete?}), which runs its
+      # block until it breaks or raises.
+      def kernel_loop?(call_node)
+        call_node.name == :loop && kernel_spelled_receiver?(call_node.receiver)
+      end
+
       # Issue #1107 — whether a `loop` call can complete normally although its declared return is `bot`.
       #
       # `Kernel#loop` is `() { () -> void } -> bot` in core RBS, yet it rescues a `StopIteration` its block
@@ -86,7 +92,7 @@ module Rigor
       # promise. A project redefinition of `loop` itself is not excluded: widening its `bot` costs precision,
       # never a false positive.
       def loop_may_complete?(call_node)
-        return false unless call_node.name == :loop && kernel_spelled_receiver?(call_node.receiver)
+        return false unless kernel_loop?(call_node)
 
         block = call_node.block
         return false if block.nil?

data/lib/rigor/inference/builtins/method_catalog.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "yaml"
+require_relative "../../rooted_glob"
 
 module Rigor
   module Inference
@@ -49,7 +50,7 @@ module Rigor
         end
 
         # Every catalogue file under {DATA_ROOT}, in a stable order.
-        def self.topic_paths = Dir[File.join(DATA_ROOT, "*.yml")]
+        def self.topic_paths = RootedGlob.glob(DATA_ROOT, "*.yml")
 
         def initialize(path:, mutating_selectors: {})
           @path = path

data/lib/rigor/inference/captured_locals.rb

@@ -6,6 +6,7 @@ require_relative "../source/node_walker"
 require_relative "block_parameter_binder"
 require_relative "element_read_widening"
 require_relative "index_write_widening"
+require_relative "intervening_ivar_reset"
 require_relative "mutation_widening"
 require_relative "optimistic_origin"
 require_relative "receiver_alias"
@@ -109,16 +110,22 @@ module Rigor
       #   `base_scope`), except that one still on its class-wide binding does not: ADR-58's declaration seed is
       #   the union of every write in the class, this body's included, so nothing the body stores can move it,
       #   and rebinding it would only drop the declaration mark that keeps its nil from being diagnostic fuel.
-      #   A nested block that rebinds `self` (`o.instance_eval`) writes another object's ivar, and a nested
-      #   `def` runs only when called; both still count, because an `instance_eval` without a receiver, or a
-      #   call to that `def` inside the body, does write this one.
+      #   Issue #1402 — an instance variable written in a nested block that runs on an object provably not `self`
+      #   (`Other.class_eval { @x = 1 }`, {InterveningIvarReset.foreign_self_block?}, its receiver typed in
+      #   `base_scope`) is that object's, and does not count; one on a receiver that may be `self` does. A class
+      #   variable or global written there counts as anywhere else: Ruby resolves a class variable lexically, and
+      #   a global is the same one whatever `self` is. A nested `def` runs only when called; it still counts,
+      #   because a call to it inside the body writes this one.
+      # @param foreign_self — the block itself runs on an object provably not `self`
+      #   ({InterveningIvarReset.foreign_self_block?} of its call): no instance variable it writes is the caller's.
+      #   Its locals, class variables and globals still count.
       # @param non_locals — the per-element fold's superset of `ivars`: the class variables and globals the body
       #   rebinds count too, on the same terms, and so does an attribute setter called on `self` (`self.w = v`)
       #   as a rebind of the instance variable it is named after, `@w`: the `attr_writer` / `attr_accessor`
       #   convention stores there, and no write node shows it. A hand-written setter storing elsewhere is not
       #   seen.
       # @return the captured names the body writes, each once, in first-write order.
-      def writes(block_node, base_scope, ivars: false, non_locals: false)
+      def writes(block_node, base_scope, ivars: false, non_locals: false, foreign_self: false)
         body = block_node.body
         return NO_NAMES if body.nil?
 
@@ -126,20 +133,44 @@ module Rigor
         names = nil
         outliving = non_locals || ivars
         Source::NodeWalker.each_with_ancestors(body) do |descendant, ancestors|
-          name =
-            if LOCAL_WRITE_NODES.include?(descendant.class)
-              captured_local_write(descendant, ancestors, base_scope) { introduced ||= introduced_locals(block_node) }
-            elsif outliving
-              if ReflectiveIvarWrite.unknown_target?(descendant)
-                (names ||= []).concat(reflective_unknown_ivars(base_scope))
-              end
-              rebindable_outliving_write(descendant, base_scope, non_locals)
+          if LOCAL_WRITE_NODES.include?(descendant.class)
+            name = captured_local_write(descendant, ancestors, base_scope) do
+              introduced ||= introduced_locals(block_node)
             end
-          (names ||= []) << name if name
+            (names ||= []) << name if name
+          elsif outliving
+            found = outliving_writes(descendant, ancestors, base_scope, non_locals, foreign_self)
+            (names ||= []).concat(found) unless found.empty?
+          end
         end
         names ? names.uniq : NO_NAMES
       end
 
+      # The non-local names `node` writes ({.reflective_unknown_ivars} for an `instance_variable_set` on `self` whose
+      # target no literal names, then {.rebindable_outliving_write}), less the instance variables when the write
+      # runs on an object provably not `self` (`foreign_self`, or a nested block {.under_foreign_self_block?}).
+      def outliving_writes(node, ancestors, base_scope, non_locals, foreign_self)
+        found = ReflectiveIvarWrite.unknown_target?(node) ? reflective_unknown_ivars(base_scope) : NO_NAMES
+        written = rebindable_outliving_write(node, base_scope, non_locals)
+        return found if written.nil? && found.empty?
+
+        names = written ? found + [written] : found
+        return names unless foreign_self || under_foreign_self_block?(ancestors, base_scope)
+
+        names.reject { |name| ivar_name?(name) }
+      end
+
+      # Issue #1402 — whether a block on the path `ancestors` runs on an object provably not `self`: its call is a
+      # {InterveningIvarReset.foreign_self_block?}, the receiver typed in `base_scope`.
+      def under_foreign_self_block?(ancestors, base_scope)
+        (1...ancestors.size).any? do |index|
+          child = ancestors[index]
+          parent = ancestors[index - 1]
+          child.is_a?(Prism::BlockNode) && parent.is_a?(Prism::CallNode) && parent.block.equal?(child) &&
+            InterveningIvarReset.foreign_self_block?(parent, base_scope)
+        end
+      end
+
       # Issue #1889 — every ivar `base_scope` binds: an `instance_variable_set` on `self` whose target no literal
       # names ({ReflectiveIvarWrite.unknown_target?}) may write any of them. One on its ADR-58 declaration seed
       # counts too, since the census behind the seed sees no reflective write; {.bind} keeps its mark.

data/lib/rigor/inference/clause_widening.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../source/node_children"
+require_relative "../type"
+require_relative "captured_locals"
+
+module Rigor
+  module Inference
+    # Issues #1231 and #1839 — a rescue clause runs after the `begin` body raised from any point in it, and an `ensure`
+    # clause after the body, its `else` or a rescue clause raised, so each local or instance variable those wrote may
+    # hold any value one of their writes gave it, or the one it entered with. The engine does not track where the body
+    # raises; a clause enters with such a name rebound to `Dynamic[top]` instead ({.widen}).
+    #
+    # Not every name the body writes: one the clause mentions, whose binding the clause reads, and one the body
+    # writes more than once, which can hold a value neither the entry nor the body's exit binds. A name written once
+    # and never mentioned leaves the clause at its entry binding, which the join past the `begin` already pairs with
+    # the body's exit binding, the value of that one write (a write in a block or loop body included: the scope a
+    # block call or loop leaves joins every iteration's).
+    module ClauseWidening
+      WRITE_NODES = Set[
+        *CapturedLocals::LOCAL_WRITE_NODES,
+        Prism::InstanceVariableWriteNode,
+        Prism::InstanceVariableOperatorWriteNode,
+        Prism::InstanceVariableOrWriteNode,
+        Prism::InstanceVariableAndWriteNode,
+        Prism::InstanceVariableTargetNode
+      ].freeze
+
+      MENTION_NODES = Set[Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, *WRITE_NODES].freeze
+
+      SCOPE_BODY_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+
+      # The names `sources` write: `names` all of them, `repeated` those written more than once, a nested block's
+      # included (it may write an outer local). A `def` or class body writes nothing here.
+      Writes = Data.define(:names, :repeated)
+
+      module_function
+
+      # The {Writes} of `sources`, or nil for none.
+      def writes(sources)
+        counts = nil
+        sources.each { |source| counts = count_writes(source, counts) if source }
+        return nil if counts.nil?
+
+        Writes.new(names: counts.keys.to_set, repeated: counts.filter_map { |name, count| name if count > 1 }.to_set)
+      end
+
+      # `scope` with each name of `writes` that `clause` mentions, or that is repeated, rebound to `Dynamic[top]` where
+      # `scope` binds it, or nil when none changes. `clause` may be nil (an empty rescue clause).
+      def widen(scope, writes, clause)
+        return nil if writes.nil?
+
+        names = mentions(clause, writes.names, writes.repeated.dup)
+        untyped = Type::Combinator.untyped
+        widened = names.reduce(scope) do |acc, name|
+          ivar = name.start_with?("@")
+          current = ivar ? scope.ivar(name) : scope.local(name)
+          next acc if current.nil? || current == untyped
+
+          ivar ? acc.with_ivar(name, untyped).without_ivar_guard(name) : acc.with_local(name, untyped)
+        end
+        widened.equal?(scope) ? nil : widened
+      end
+
+      # `counts` with each write under `node` counted.
+      def count_writes(node, counts)
+        return counts if SCOPE_BODY_NODES.any? { |klass| node.is_a?(klass) }
+
+        if WRITE_NODES.include?(node.class)
+          counts ||= Hash.new(0)
+          counts[node.name] += 1
+        end
+        node.rigor_each_child { |child| counts = count_writes(child, counts) }
+        counts
+      end
+
+      # `found` with each name of `among` that `node` mentions added.
+      def mentions(node, among, found)
+        return found if node.nil? || SCOPE_BODY_NODES.any? { |klass| node.is_a?(klass) }
+
+        found << node.name if MENTION_NODES.include?(node.class) && among.include?(node.name)
+        node.rigor_each_child { |child| found = mentions(child, among, found) }
+        found
+      end
+      private_class_method :count_writes, :mentions
+    end
+  end
+end

data/lib/rigor/inference/definer_resolution.rb

@@ -61,7 +61,7 @@ module Rigor
         flavor = question == :arity ? :arity : :methods
         chain = Scope::ResolutionChain.for(scope, class_name.to_s, side, flavor)
 
-        reads_visibility = VISIBILITY_QUESTIONS.include?(question)
+        reads_visibility = VISIBILITY_QUESTIONS.include?(question) ? question : nil
         hits = candidates(scope, chain, method_name, from, answer_in, reads_visibility)
         return UNKNOWN if hits.nil?
 
@@ -159,23 +159,39 @@ module Rigor
       end
 
       # The implicit tail after a chain's last project superclass: `Object` (with `Kernel` and `BasicObject`) on the
-      # instance side, `#<Class:Object>` through `Class`, `Module` and `Kernel` on the singleton side.
+      # instance side, `#<Class:Object>` through `Class`, `Module` and `Kernel` on the singleton side. It may answer
+      # where RBS declares the name there, where the last class's superclass is not a constant the tables can follow
+      # (#1624, {Scope::ResolutionChain#opaque_tail?}: `class C < Struct.new(:a)`, `C = Class.new(Base)`), and where
+      # the project itself reopens a tail class with the name (`class Object; def self.x`), which is no entry on the
+      # chain because the class names no superclass.
       def implicit_object_answers?(scope, chain, method_name)
-        !external_lacks?(scope, ["Object"], chain.side, method_name)
+        !external_lacks?(scope, ["Object"], chain.side, method_name) || chain.opaque_tail?(scope) ||
+          project_tail_defines?(scope, chain.side, method_name)
+      end
+
+      # The implicit tail's classes and the side each is read on, per chain side: a class object reaches the instance
+      # methods of `Class`, `Module`, `Object`, `Kernel` and `BasicObject` and the singleton methods of `Object` and
+      # `BasicObject`.
+      CLASS_OBJECT_TAIL = %w[Class Module Object Kernel BasicObject].product([:instance]) +
+                          %w[Object BasicObject].product([:singleton])
+      IMPLICIT_TAIL = Ractor.make_shareable({ instance: %w[Object Kernel BasicObject].product([:instance]),
+                                              singleton: CLASS_OBJECT_TAIL })
+      private_constant :CLASS_OBJECT_TAIL, :IMPLICIT_TAIL
+
+      # Whether a project reopening of a tail class records the name: a `def`, whose read files the method edge, or
+      # an `attr_*` / `define_method` the existence table holds.
+      def project_tail_defines?(scope, side, method_name)
+        IMPLICIT_TAIL.fetch(side).any? do |name, kind|
+          (kind == :singleton ? scope.singleton_def_for(name, method_name) : scope.user_def_for(name, method_name)) ||
+            scope.discovered_method?(name, method_name, kind)
+        end
       end
 
       # True only for an ancestor RBS knows whose declaration lacks the name, on the side the entry stands for: an
       # external superclass on a singleton chain (`:singleton`, its whole tail) is asked for a singleton method, an
       # extended module (`:instance`) and every instance-side entry for an instance method.
       def external_lacks?(scope, candidates, side, method_name)
-        return Scope::ResolutionChain::Relevance.external_lacks?(scope, candidates, method_name) if side == :instance
-
-        known = candidates.find { |candidate| Rigor::Reflection.rbs_class_known?(candidate, scope: scope) }
-        return false if known.nil?
-
-        Rigor::Reflection.singleton_method_definition(known, method_name, scope: scope).nil?
-      rescue StandardError
-        false
+        Scope::ResolutionChain::Relevance.external_lacks_on?(scope, candidates, side, method_name)
       end
 
       # What a candidate set says, for {Scope::ResolutionChain#settle} to compare across worlds.
@@ -198,14 +214,23 @@ module Rigor
       # that reads the visibility (`reads_visibility`): a slot is contested there for a visibility call the walk
       # cannot place (an uncertain toggle, `private(*names)`, `private def self.x`), which leaves the definer and its
       # `def` certain; a possible `def` or `attr_*` call contests its def-node slot or its name's `possible` side too.
+      #
+      # `reads_visibility` is the question when it reads one. The `:visibility` question does not read a contested
+      # instance def-node slot (#1989): it answers from the visibility slot and the name's existence, not from the
+      # `def` body, and a possible `def` that contests the slot also makes its name `possible`. The slot is contested
+      # alone where a later `attr_*` replaced the `def`: the attr writes the name's visibility slot, so the reader's
+      # visibility is certain. A `define_method` or alias that replaced it contests the visibility slot as well, which
+      # this question does read.
       def possible?(scope, hit, method_name, reads_visibility)
         discovery = scope.discovery
         owner = hit.owner
         kind = hit.side == :singleton ? :singleton : :instance
         nodes = kind == :singleton ? :discovered_singleton_def_nodes : :discovered_def_nodes
         discovery.possible_method?(owner, method_name, kind) ||
-          discovery.contested?(nodes, [owner, method_name.to_sym]) ||
-          (reads_visibility && discovery.contested?(:discovered_method_visibilities, [owner, method_name.to_sym])) ||
+          (!(reads_visibility == :visibility && kind == :instance) &&
+           discovery.contested?(nodes, [owner, method_name.to_sym])) ||
+          (reads_visibility && discovery.contested?(:discovered_method_visibilities,
+                                                    [owner, visibility_slot(method_name, kind)])) ||
           discovery.contested?(:discovered_parameter_envelopes, [owner, [kind, method_name.to_sym]])
       end
 
@@ -235,20 +260,61 @@ module Rigor
 
       # The first project entry that records the name (a discovered method, an instance `def` the def table
       # holds, or a visibility change such as `private :foo` recorded for it), with its visibility (`:public` where
-      # none was stated).
+      # none was stated). Issue #1984 — a singleton-side entry reads its class's singleton slot
+      # (`private_class_method :new` records `new` there with no `def`), never the instance one.
       def visibility_answer(scope, method_name)
         lambda do |chain, from|
           first_hit(chain, scope, from) do |entry|
             kind = entry.side == :singleton ? :singleton : :instance
-            next unless scope.discovered_method?(entry.name, method_name, kind) ||
-                        (kind == :instance && (scope.user_def_for(entry.name, method_name) ||
-                                               scope.discovered_method_visibility(entry.name, method_name)))
+            recorded = side_visibility(scope, entry.name, method_name, kind)
+            next unless scope.discovered_method?(entry.name, method_name, kind) || recorded ||
+                        (kind == :instance && scope.user_def_for(entry.name, method_name))
+
+            recorded || :public
+          end
+        end
+      end
+
+      def side_visibility(scope, owner, method_name, kind)
+        if kind == :singleton
+          scope.discovered_method_visibilities.dig(owner.to_s, visibility_slot(method_name, :singleton)) ||
+            self_extended_copy_visibility(scope, owner, method_name)
+        else
+          scope.discovered_method_visibility(owner, method_name)
+        end
+      end
 
-            scope.discovered_method_visibility(entry.name, method_name) || :public
+      # Issue #2059 — a module that `extend`s itself reaches its own instance method from the singleton side, and the
+      # extends fold copies that receiverless `def` onto the module's singleton entry, where no singleton slot records
+      # it: the instance slot's visibility is what Ruby applies (`module ES; extend self; private def x` makes `ES.x`
+      # private). A module function's singleton copy is public whatever its instance copy is, so a `module_function`
+      # row for the name in any file answers nil, as does a contested instance slot.
+      def self_extended_copy_visibility(scope, owner, method_name)
+        node = scope.singleton_def_for(owner, method_name)
+        return nil if node.nil? || !node.receiver.nil?
+        return nil unless scope.discovered_extends[owner.to_s]&.include?(owner.to_s)
+        return nil if scope.discovery.contested?(:discovered_method_visibilities, [owner.to_s, method_name.to_sym])
+        return nil if module_function_row?(scope, owner, method_name)
+
+        scope.discovered_method_visibility(owner, method_name)
+      end
+
+      # Whether any file's deferred ranges carry a `module_function` row (`:both` or `:singleton`) for the name on
+      # `owner` (`ModuleFunctionState`).
+      def module_function_row?(scope, owner, method_name)
+        name = method_name.to_sym
+        scope.discovered_deferred_ranges.each_value.any? do |rows|
+          rows.any? do |(_start, _finish, row_name, kind, row_owner)|
+            row_name == name && row_owner == owner.to_s && kind != :instance
           end
         end
       end
 
+      # The key of a name's slot in the visibility table on `kind`'s side (`ScopeIndexer#visibility_slot`).
+      def visibility_slot(method_name, kind)
+        kind == :singleton ? [:singleton, method_name.to_sym] : method_name.to_sym
+      end
+
       def first_hit(chain, scope, from)
         index = from - 1
         found = nil
@@ -265,9 +331,10 @@ module Rigor
       end
 
       private_class_method :override_answer, :retro_position, :candidates, :past_fold_copies, :decided,
-                           :external_may_answer?, :implicit_object_answers?, :external_lacks?,
+                           :external_may_answer?, :implicit_object_answers?, :project_tail_defines?, :external_lacks?,
                            :outcomes, :collapse, :possible?,
-                           :default_answer, :definer_answer, :visibility_answer, :first_hit
+                           :default_answer, :definer_answer, :visibility_answer, :side_visibility,
+                           :self_extended_copy_visibility, :module_function_row?, :visibility_slot, :first_hit
     end
   end
 end

data/lib/rigor/inference/expression_typer.rb

@@ -5,6 +5,7 @@ require "prism"
 require_relative "../type"
 require_relative "../reflection"
 require_relative "../ast"
+require_relative "clause_widening"
 require_relative "../source/constant_path"
 require_relative "../source/node_children"
 require_relative "../source/node_walker"
@@ -41,6 +42,7 @@ require_relative "receiver_alias"
 require_relative "repeated_or_writes"
 require_relative "singleton_object_constant"
 require_relative "refined_dispatch"
+require_relative "singleton_external_ahead"
 require_relative "stored_block_call"
 require_relative "struct_fold_safety"
 require_relative "unknown_store_widening"
@@ -1208,17 +1210,22 @@ module Rigor
             Type::Combinator.constant_of(nil)
           end
 
-        rescue_types = rescue_chain_types(rescue_clause)
+        rescue_types = rescue_chain_types(rescue_clause, node.statements)
         Type::Combinator.union(primary_type, *rescue_types)
       end
 
       # Issue #1360 — the evaluator binds `$!` in a rescue clause it enters; a clause typed here, such as one in a
       # `begin` passed as an argument, reads `$!`, `$@` and `$?` unbound rather than an enclosing clause's.
-      def rescue_chain_types(rescue_node)
-        arm_typer = typer_under(rescue_arm_scope)
+      #
+      # Issue #1839 — it also reads each name the `body` writes as `Dynamic[top]` ({ClauseWidening}), as the evaluator's
+      # rescue clause does: `[begin; conn = make; work; rescue; conn; end]` holds the connection, not the entry's `nil`.
+      def rescue_chain_types(rescue_node, body)
+        arm_scope = rescue_arm_scope
+        writes = ClauseWidening.writes([body])
         types = []
         current = rescue_node
         while current
+          arm_typer = typer_under(ClauseWidening.widen(arm_scope, writes, current.statements) || arm_scope)
           types << arm_typer.send(:statements_or_nil, current.statements)
           current = current.subsequent
         end
@@ -1279,11 +1286,23 @@ module Rigor
       def type_of_range(node)
         left_static, left = static_range_endpoint(node.left)
         right_static, right = static_range_endpoint(node.right)
-        return Type::Combinator.constant_of(Range.new(left, right, node.exclude_end?)) if left_static && right_static
+        if left_static && right_static
+          range = static_range_value(left, right, node.exclude_end?)
+          return Type::Combinator.constant_of(range) if range
+        end
 
         nominal_range_for_endpoints(node.left, node.right)
       end
 
+      # The `Range` the static endpoints denote, or nil when Ruby would refuse to build it (`1.."a"`,
+      # `"a"..1` raise `ArgumentError: bad value for range`). The literal is a runtime error,
+      # not a constant, so the fold declines and the caller types it as a plain Range.
+      def static_range_value(left, right, exclude_end)
+        Range.new(left, right, exclude_end)
+      rescue ArgumentError
+        nil
+      end
+
       # Derives `Nominal[Range, [T]]` from the endpoint expression types when at least one endpoint is
       # statically typeable. The element parameter is the union of the endpoint types (lifted from
       # `Constant<v>` to `Nominal<v.class>` so the carrier matches what `Range#each` would yield). Falls back
@@ -2583,6 +2602,10 @@ module Rigor
 
         def_node, owner = resolve_singleton_def_with_owner(receiver.class_name, method_name)
         return nil if def_node.nil?
+        # Issue #1936 — a contested slot holds a `def` a later definer may have replaced
+        # (`singleton_class.alias_method :x, :y` after `def self.x`), or one that may not have run: its body is not
+        # proven to be the method Ruby calls, so the call falls through to `Dynamic`.
+        return nil if scope.discovery.contested?(:discovered_singleton_def_nodes, [owner, method_name.to_sym])
 
         result = infer_user_method_return(def_node, receiver, arg_types, yield_type: block_type)
         return result if result.nil?
@@ -2597,6 +2620,10 @@ module Rigor
       # `discovered_def_nodes` / `discovered_superclasses` / `discovered_includes`, and this walk reads a
       # fourth table those three do not imply. Keying on what the answer actually depends on is the #682
       # lesson — a memo that outlives its inputs serves one scope's answer to another.
+      #
+      # It is the TYPING read only, so it also withholds (`[nil, nil]`, the call types `Dynamic`) where an external
+      # ancestor may answer ahead of the definer found (#1572: `extend M; extend Enumerable` makes `C.to_a`
+      # `Enumerable#to_a`, which the reader passes over). The existence reads keep the reader's own answer.
       def resolve_singleton_def_with_owner(class_name, method_name)
         by_singleton = (class_graph_buckets[:singleton_def] ||= {}.compare_by_identity)
         cache = (by_singleton[scope.discovered_singleton_def_nodes] ||= {})
@@ -2604,7 +2631,10 @@ module Rigor
         key = method_name.to_sym
         return table[key] if table.key?(key)
 
-        table[key] = scope.singleton_def_through_ancestors(class_name, method_name)
+        found = scope.singleton_def_through_ancestors(class_name, method_name)
+        owner = found.last
+        found = [nil, nil] if owner && SingletonExternalAhead.withhold?(scope, class_name, method_name, owner)
+        table[key] = found
       end
 
       # The project-side singleton-method band: a `Foo.bar` call resolved against a `class << …` / `def self.…`