rigortype 0.4.4 → 0.4.6

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/deep_erasure.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../type"
+require_relative "../source/node_walker"
+require_relative "mutation_rejoin"
+require_relative "receiver_alias"
+
+module Rigor
+  module Inference
+    # A loop hands its collection's own elements to its body (issue #2262), so a body that mutates one in place
+    # changes a shape that the collection's binding still carries one level down. This module is the two halves of
+    # dropping that shape: whether the body mutates an element, and the type with every shape dropped at every depth.
+    module DeepErasure
+      module_function
+
+      # {MutationWidening.widen_tuple} / {MutationWidening.widen_hash_shape} applied at every depth: each `Tuple` /
+      # `HashShape` the type holds, as a union member or a type argument, drops to its nominal, so `[[1]]` reads
+      # `Array[Array[Integer]]`. A loop's element is the collection's own object, so a body that mutates it in place
+      # (`x << 2`) changes a shape one level down that the collection's binding still carries.
+      def widen(type)
+        case type
+        when Type::Tuple then widen_args(MutationWidening.widen_tuple(type))
+        when Type::HashShape then widen_args(MutationWidening.widen_hash_shape(type))
+        when Type::Nominal then widen_args(type)
+        when Type::Difference then widen(type.base)
+        when Type::Union then Type::Combinator.union(*type.members.map { |member| widen(member) })
+        else Type::Combinator.widen_value_pinned(type)
+        end
+      end
+
+      def widen_args(nominal)
+        return nominal unless nominal.is_a?(Type::Nominal) && !nominal.type_args.empty?
+
+        Type::Combinator.nominal_of(nominal.class_name, type_args: nominal.type_args.map { |arg| widen(arg) })
+      end
+
+      # The parameter nodes whose names a block (or a `for` index) binds to the collection's elements.
+      ELEMENT_PARAMETER_NODES = [
+        Prism::RequiredParameterNode, Prism::OptionalParameterNode, Prism::RestParameterNode,
+        Prism::KeywordRestParameterNode, Prism::LocalVariableTargetNode
+      ].freeze
+      ELEMENT_WRITE_NODES = [
+        Prism::IndexOperatorWriteNode, Prism::IndexOrWriteNode, Prism::IndexAndWriteNode,
+        Prism::CallOperatorWriteNode, Prism::CallOrWriteNode, Prism::CallAndWriteNode,
+        Prism::IndexTargetNode, Prism::CallTargetNode
+      ].freeze
+      private_constant :ELEMENT_PARAMETER_NODES, :ELEMENT_WRITE_NODES
+
+      # True when `body` mutates in place a value that a name in `names` (a loop's element) holds: a mutator
+      # (`MutationWidening::SHAPE_MUTATORS`) called on a read or an index chain rooted at it (`x << 1`,
+      # `x[0].push(1)`, `x[0] = 1`), or an operator write on one (`x[0] += 1`). Every name a block or a
+      # `for` inside the body binds counts as an element too (`x.each { |y| y << 1 }`, `for c in x; c << 1; end`),
+      # and so does `it` / `_1` wherever it is read, and an accumulator parameter (`inject([]) { |acc, e| acc << e }`):
+      # the rule is wider than "an element", which only loses precision. It does not follow an alias (`y = x`) or
+      # an element passed to a call (`add(x)`), which the straight-line widening does not either.
+      def element_mutation?(body, names)
+        return false if body.nil?
+
+        names |= nested_parameter_names(body)
+        Source::NodeWalker.each(body).any? { |node| element_mutation_site?(node, names) }
+      end
+
+      # The names `parameters` (a block's parameter list, or a `for` index) binds.
+      def parameter_names(parameters)
+        return [] if parameters.nil?
+
+        Source::NodeWalker.each(parameters).filter_map do |node|
+          node.name if ELEMENT_PARAMETER_NODES.include?(node.class)
+        end
+      end
+
+      def nested_parameter_names(body)
+        Source::NodeWalker.each(body).flat_map do |node|
+          case node
+          when Prism::BlockNode then parameter_names(node.parameters)
+          when Prism::ForNode then parameter_names(node.index)
+          else []
+          end
+        end
+      end
+
+      def element_mutation_site?(node, names)
+        if node.is_a?(Prism::CallNode)
+          MutationWidening::SHAPE_MUTATORS.include?(node.name) && element_rooted?(node.receiver, names)
+        else
+          ELEMENT_WRITE_NODES.include?(node.class) && element_rooted?(node.receiver, names)
+        end
+      end
+
+      def element_rooted?(node, names)
+        node = node.receiver while node.is_a?(Prism::CallNode) && node.receiver
+        node = node.body.body.last while node.is_a?(Prism::ParenthesesNode) && node.body.is_a?(Prism::StatementsNode)
+        case node
+        when Prism::LocalVariableReadNode then names.include?(node.name) || /\A_[1-9]\z/.match?(node.name)
+        when Prism::ItLocalVariableReadNode then true
+        else false
+        end
+      end
+
+      # A block call hands each of its receiver's elements to the block's parameters, and a body that mutates one in
+      # place (`a.each { |x| x << 2 }`) changes the shape the receiver's binding still carries one level down
+      # (`[[1]]`). The receiver's variables drop their shapes at every depth ({widen}), as a `for` loop's
+      # value does ({StatementEvaluator#for_collection_after}).
+      def widen_element_aliases(receiver, body, names, scope)
+        return scope unless element_mutation?(body, names)
+
+        widen_receiver(receiver, scope)
+      end
+
+      def widen_receiver(receiver, scope)
+        ReceiverAlias.candidates(receiver).reduce(scope) { |acc, read| widen_read(read, acc) }
+      end
+
+      # `a.each(&:strip!)`: a block argument naming a mutator mutates every element it is handed.
+      def symbol_proc_mutation?(block)
+        block.is_a?(Prism::BlockArgumentNode) && block.expression.is_a?(Prism::SymbolNode) &&
+          MutationWidening::SHAPE_MUTATORS.include?(block.expression.unescaped.to_sym)
+      end
+
+      def widen_symbol_proc(call_node, scope) = widen_receiver(call_node.receiver, scope)
+
+      def widen_read(read, scope)
+        getter, builder = MutationWidening::ALIAS_ACCESSORS[read.class]
+        return scope if getter.nil?
+
+        name = ReceiverAlias.read_name(read)
+        current = scope.public_send(getter, name)
+        return scope if current.nil?
+
+        widened = widen(current)
+        return scope if widened == current
+
+        MutationRejoin.rebind(scope, builder, name, widened, pre_state: current, kind: getter)
+      end
+    end
+  end
+end

data/lib/rigor/inference/def_return_typer.rb

@@ -5,6 +5,7 @@ require "prism"
 require_relative "../type"
 require_relative "../source/node_children"
 require_relative "return_barrier"
+require_relative "optimistic_origin"
 
 module Rigor
   module Inference
@@ -21,10 +22,16 @@ module Rigor
     #
     # Extracted from `Rigor::SigGen::Generator#infer_return_type` so `LineTypeCollector` (`rigor annotate`'s
     # def-line annotator) and the sig-generator share one source of truth.
+    #
+    # `keep_lookup_nil: true` is the reading a signature needs (#2197). The engine reads a lookup that can miss
+    # (`Hash#[]`, `Array#first`, the {OptimisticOrigin} family) as nil-free on purpose, so `if h[k]` stays
+    # silent, but a `-> V` written into `sig/` is a contract that every caller's `nil` check is dead code. Each
+    # returned expression whose value is such a lookup therefore contributes `nil` beside its type. Only the
+    # value positions a lookup's `nil` reaches the return through are followed ({#optimistic_value?}).
     module DefReturnTyper
       module_function
 
-      def call(def_node, scope_index)
+      def call(def_node, scope_index, keep_lookup_nil: false)
         body = def_node.body
         return nil if body.nil?
 
@@ -37,11 +44,152 @@ module Rigor
         last_type = safe_type_of(inner_scope, last)
         return nil if last_type.nil?
 
-        union_with_explicit_returns(body, last_type, scope_index)
+        lookup_context = keep_lookup_nil ? LookupContext.new(scope_index, truthy_guards(body)) : nil
+        last_type = with_lookup_nil(last_type, last, inner_scope, lookup_context) if lookup_context
+        union_with_explicit_returns(body, last_type, scope_index, lookup_context: lookup_context)
       rescue StandardError
         nil
       end
 
+      # What {#optimistic_value?} reads beside a node's scope: the engine's per-node scopes, and for each lookup
+      # under a guard the source of the guarding predicates ({#truthy_guards}).
+      LookupContext = Data.define(:scope_index, :guards)
+
+      def with_lookup_nil(type, node, scope, context = nil)
+        return type unless optimistic_value?(node, scope, context)
+
+        Type::Combinator.union(type, Type::Combinator.constant_of(nil))
+      end
+
+      # Whether `node`'s value can be the `nil` an optimistic lookup's miss returns: the lookup itself (a call
+      # the dispatcher marked, or `recv&.m` over one), a local or ivar bound to one, or a branch or operand that
+      # hands its value on. `a && b` hands on either operand (a falsy `a`, a missed lookup's `nil` included, is
+      # the result); `a || b` hands on `b` only, since `a` is returned only when truthy, so `h[k] || 0` stays
+      # nil-free. `x ||= v` and `x &&= v` hand on `v` and, for `&&=`, the binding. A call ON the lookup
+      # (`h[k].to_s`) is a different value.
+      #
+      # Each child is read under the scope the engine recorded for it (`scope_index`), so a branch a guard narrows
+      # (`v ? v : "d"`, `return "z" unless v`) reads the binding the narrowing left, not the enclosing one.
+      def optimistic_value?(node, scope, context = nil)
+        scope = context&.scope_index&.[](node) || scope
+        case node
+        when Prism::CallNode then optimistic_call?(node, scope, context)
+        when Prism::LocalVariableReadNode then !scope.optimistic_local(node.name).nil?
+        when Prism::InstanceVariableReadNode then !scope.optimistic_ivar(node.name).nil?
+        when Prism::AndNode then [node.left, node.right].any? { optimistic_value?(it, scope, context) }
+        when Prism::OrNode then optimistic_value?(node.right, scope, context)
+        else optimistic_write?(node, scope, context) || optimistic_branch?(node, scope, context)
+        end
+      end
+
+      def optimistic_call?(node, scope, context)
+        if scope.optimistic_origins[node]
+          return false if guarded_lookup?(node, context) || non_empty_end?(node, scope)
+
+          return true
+        end
+        node.safe_navigation? && optimistic_value?(node.receiver, scope, context)
+      end
+
+      # `return h[k] if h[k]`, `h[k] ? h[k] : d`: the same lookup, read again under a predicate that just found it
+      # truthy. Only a lookup whose receiver and arguments are plain reads or literals counts, so the second read
+      # sees what the first did.
+      GUARDABLE_LOOKUPS = %i[[] first last dig].freeze
+      private_constant :GUARDABLE_LOOKUPS
+
+      def guarded_lookup?(node, context)
+        return false if context.nil? || !GUARDABLE_LOOKUPS.include?(node.name)
+        return false unless [node.receiver, *node.arguments&.arguments].all? { stable_operand?(it) }
+
+        context.guards.fetch(node, EMPTY_GUARDS).include?(node.slice)
+      end
+
+      EMPTY_GUARDS = [].freeze
+      private_constant :EMPTY_GUARDS
+
+      def stable_operand?(node)
+        case node
+        when Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::SymbolNode, Prism::StringNode,
+             Prism::IntegerNode, Prism::SelfNode, Prism::ConstantReadNode then true
+        else false
+        end
+      end
+
+      # `a.first` / `a.last` on a receiver the engine has narrowed to a non-empty array (`a.empty? ? d : a.first`)
+      # cannot miss.
+      def non_empty_end?(node, scope)
+        return false unless %i[first last].include?(node.name) && node.arguments.nil? && node.receiver
+
+        receiver = scope.type_of(node.receiver)
+        receiver.is_a?(Type::Difference) && receiver.removed == Type::Combinator.tuple_of
+      rescue StandardError
+        false
+      end
+
+      def optimistic_write?(node, scope, context)
+        case node
+        when Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode,
+             Prism::LocalVariableOrWriteNode, Prism::InstanceVariableOrWriteNode
+          optimistic_value?(node.value, scope, context)
+        when Prism::LocalVariableAndWriteNode
+          !scope.optimistic_local(node.name).nil? || optimistic_value?(node.value, scope, context)
+        when Prism::InstanceVariableAndWriteNode
+          !scope.optimistic_ivar(node.name).nil? || optimistic_value?(node.value, scope, context)
+        else false
+        end
+      end
+
+      # The value-carrying children of a statement list or a conditional: any of them can be the value returned.
+      def optimistic_branch?(node, scope, context)
+        value_branches(node).any? { |branch| !branch.nil? && optimistic_value?(branch, scope, context) }
+      end
+
+      # The lookup a truthy arm (the body of an `if` or ternary, the `else` of an `unless`) reads FIRST, mapped to
+      # the source of the predicate that just tested it, for {#guarded_lookup?}. Only the first expression, or the
+      # value of a first `return`, counts: anything run between the test and the re-read (`h.delete(k)`, a
+      # reassignment, a block, `yield`, another call that mutates the receiver) can make the re-read miss.
+      def truthy_guards(body)
+        guards = {}.compare_by_identity
+        collect_truthy_guards(body, guards)
+        guards
+      end
+
+      def collect_truthy_guards(node, guards)
+        return unless node.is_a?(Prism::Node)
+
+        predicate, arm = truthy_arm(node)
+        first = first_value(arm)
+        guards[first] = [predicate.slice] if first
+        node.rigor_each_child { collect_truthy_guards(it, guards) }
+      end
+
+      def first_value(arm)
+        return nil unless arm.is_a?(Prism::StatementsNode)
+
+        first = arm.body.first
+        args = first.is_a?(Prism::ReturnNode) ? first.arguments&.arguments : nil
+        args&.size == 1 ? args.first : first
+      end
+
+      def truthy_arm(node)
+        case node
+        when Prism::IfNode then [node.predicate, node.statements]
+        when Prism::UnlessNode then [node.predicate, node.else_clause&.statements]
+        end
+      end
+
+      def value_branches(node)
+        case node
+        when Prism::ParenthesesNode then [node.body && body_last_expression(node.body)]
+        when Prism::StatementsNode, Prism::BeginNode then [body_last_expression(node)]
+        when Prism::IfNode then [node.statements, node.subsequent]
+        when Prism::UnlessNode then [node.statements, node.else_clause]
+        when Prism::ElseNode, Prism::WhenNode, Prism::InNode then [node.statements]
+        when Prism::CaseNode, Prism::CaseMatchNode then [*node.conditions, node.else_clause]
+        else []
+        end
+      end
+
       def body_last_expression(body)
         case body
         when Prism::StatementsNode then body.body.last
@@ -50,27 +198,27 @@ module Rigor
         end
       end
 
-      def union_with_explicit_returns(body, last_type, scope_index)
+      def union_with_explicit_returns(body, last_type, scope_index, lookup_context: nil)
         return_types = []
-        collect_return_types(body, scope_index, return_types)
+        collect_return_types(body, scope_index, return_types, lookup_context: lookup_context)
         return last_type if return_types.empty?
 
         Type::Combinator.union(last_type, *return_types)
       end
 
-      def collect_return_types(node, scope_index, out)
+      def collect_return_types(node, scope_index, out, lookup_context: nil)
         return unless node.is_a?(Prism::Node)
         return if ReturnBarrier.node?(node)
 
-        type_return_node(node, scope_index, out) if node.is_a?(Prism::ReturnNode)
+        type_return_node(node, scope_index, out, lookup_context: lookup_context) if node.is_a?(Prism::ReturnNode)
         # A barrier call's receiver and arguments still run in the method; only its block is cut off.
         barrier_block = node.block if node.is_a?(Prism::CallNode) && ReturnBarrier.block_call?(node)
         node.rigor_each_child do |c|
-          collect_return_types(c, scope_index, out) unless c.equal?(barrier_block)
+          collect_return_types(c, scope_index, out, lookup_context: lookup_context) unless c.equal?(barrier_block)
         end
       end
 
-      def type_return_node(return_node, scope_index, out)
+      def type_return_node(return_node, scope_index, out, lookup_context: nil)
         args = return_node.arguments&.arguments || []
         if args.empty?
           out << Type::Combinator.constant_of(nil)
@@ -84,7 +232,9 @@ module Rigor
         return unless args.size == 1
 
         type = safe_type_of(scope, args.first)
-        out << type unless type.nil?
+        return if type.nil?
+
+        out << (lookup_context ? with_lookup_nil(type, args.first, scope, lookup_context) : type)
       end
 
       def safe_type_of(scope, node)

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,27 @@ 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.
+      #
+      # Issue #2134 — the contest is a read of the slot, so a question that reads it files `visibility:<owner>#<name>`:
+      # an answer block may answer from RBS without reading the slot itself (`nearest_ancestor_method_def`).
       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
+        Analysis::DependencyRecorder.read_visibility(owner, method_name) if reads_visibility
         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 +264,71 @@ 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_visibility(owner, method_name, singleton: true) ||
+            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`).
+      #
+      # Issue #2161 — the answer reads every file's rows, so it records `visibility:<owner>#<name>` whichever way it
+      # answers: `ScopeIndexer.visibility_entries` carries each file's rows of this shape, so a file that starts or
+      # stops writing one fires the key. A swap from `private :x` to `module_function :x` in a reopening leaves the
+      # file's visibility table and declared classes as they were, and fires nothing else. The caller's own
+      # visibility reads record the same key today; this one keeps the reader's edge where it reads.
+      #
+      # Issue #2209 — a row named {ModuleFunctionState::ANY_ROW_NAME} (a `module_function` spelling whose names the
+      # prescan cannot read) stands for every name of its owner, so it counts too, and its key is read as well
+      # ({ModuleFunctionState.row_names}).
+      def module_function_row?(scope, owner, method_name)
+        names = ModuleFunctionState.row_names(method_name).each { Analysis::DependencyRecorder.read_visibility(owner, it) }
+        scope.discovered_deferred_ranges.each_value.any? do |rows|
+          rows.any? do |(_start, _finish, row_name, kind, row_owner)|
+            names.include?(row_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 +345,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/error_info.rb

@@ -53,8 +53,8 @@ module Rigor
       # made a class guard on `$!` itself narrow it; #1447 narrows this decline to the guards that still do not.
       #
       # `$@` calls the exception's `backtrace`, which is an `Array[String]` for a raised exception. It is left unbound
-      # in a program that defines a method named `backtrace` anywhere, which may return anything, and in a clause
-      # whose body calls `set_backtrace`, which may set it to nil.
+      # in a program that defines a method named `backtrace` anywhere, which may return anything, in a clause whose
+      # body calls `set_backtrace`, which may set it to nil, and in a clause whose body never reads it.
       #
       # `$?` is unbound because the exception may have been raised while a subprocess waited: a backtick, `%x` or
       # `system` sets `$?` to nil before it runs the child, so a `Timeout::Error`, an `Interrupt` or a `Thread#raise`
@@ -65,6 +65,10 @@ module Rigor
         return entered if guarded?(body, reference)
 
         entered = entered.with_global(ERROR_INFO, rescued_type(exception_type, scope))
+        # Issue #1967 — a clause that never reads `$@` leaves it unbound without asking about `backtrace`: the answer
+        # could not reach a diagnostic, and asking records a `defines:backtrace` edge that re-checked every `rescue`
+        # in the program whenever such a def came or went.
+        return entered unless backtrace_read?(body)
         return entered if calls_set_backtrace?(body) || BlockCallTiming.project_defines_anywhere?(:backtrace, scope)
 
         entered.with_global(BACKTRACE, backtrace_type)
@@ -114,7 +118,17 @@ module Rigor
         node.rigor_each_child { |child| found ||= calls_set_backtrace?(child) }
         found
       end
-      private_class_method :guard?, :error_info_read?, :calls_set_backtrace?
+
+      # True when `node` reads `$@` anywhere in it, a block included. An empty clause (nil) reads nothing.
+      def backtrace_read?(node)
+        return false unless node.is_a?(Prism::Node)
+        return node.name == BACKTRACE if node.is_a?(Prism::GlobalVariableReadNode)
+
+        found = false
+        node.rigor_each_child { |child| found ||= backtrace_read?(child) }
+        found
+      end
+      private_class_method :guard?, :error_info_read?, :calls_set_backtrace?, :backtrace_read?
 
       # True when `node` reads `$!`, `$@` or `$?` anywhere in it: the gate on typing a rescue modifier's fallback
       # under {.modifier_entry}, which most fallbacks (`rescue nil`) never need.