rigortype 0.4.3 → 0.4.5

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?
@@ -165,7 +171,12 @@ module Rigor
       # nothing for names this rare, and the block-return pass is no independent check here: it types a
       # self-call to an overridden `raise` as Kernel's `bot` too, so a missed override is a wrong `bot`.
       # {LastLine.reads_line?} declines on it the same way for `gets` and `readline`.
+      #
+      # Issue #1459 — the answer reads every project file's tables whole, so it records a `defines:<name>` edge
+      # whichever way it answers: an edit that makes a file start or stop defining the name re-checks the reader
+      # (`Incremental.changed_defined_names`). A `pre_eval:` patch moves the snapshot's own fingerprint.
       def project_defines_anywhere?(method_name, scope)
+        Analysis::DependencyRecorder.read_missing(:defines, method_name) if Analysis::DependencyRecorder.active?
         return true if scope.top_level_def_for(method_name)
         # `discovered_methods` withholds a plain cross-file `def` (the ADR-17 monkey-patch contract); the
         # def-node tables still carry it, on both sides.

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,9 +6,11 @@ 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"
+require_relative "reflective_ivar_write"
 require_relative "unknown_store_widening"
 
 module Rigor
@@ -108,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?
 
@@ -125,17 +133,51 @@ 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
-              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.
+      def reflective_unknown_ivars(base_scope)
+        base_scope.ivars.keys
+      end
+
       def rebindable_outliving_write(node, base_scope, non_locals)
         name = outliving_write_name(node, non_locals)
         name if name && rebindable_non_local?(base_scope, name)
@@ -151,8 +193,12 @@ module Rigor
         yield.include?(name) ? nil : name
       end
 
-      # The non-local `node` rebinds under `non_locals:` — or, without it, the instance variable only.
+      # The non-local `node` rebinds under `non_locals:` — or, without it, the instance variable only. A literal-name
+      # `instance_variable_set` on `self` ({ReflectiveIvarWrite.literal_name}) is a write of that ivar under either.
       def outliving_write_name(node, non_locals)
+        reflective = ReflectiveIvarWrite.literal_name(node)
+        return reflective if reflective
+
         name = non_local_write_name(node)
         non_locals || (name && ivar_name?(name) && NON_LOCAL_WRITE_NODES.include?(node.class)) ? name : nil
       end
@@ -201,13 +247,21 @@ module Rigor
       # it the miss answer the mark records (issue #1302).
       def bind(scope, name, type, optimistic: nil)
         case variable_kind(name)
-        when :ivar then OptimisticOrigin.carry_ivar_mark(scope, scope.with_ivar(name, type), name, optimistic)
+        when :ivar then bind_ivar(scope, name, type, optimistic)
         when :cvar then scope.with_cvar(name, type)
         when :global then scope.with_global(name, type)
         else OptimisticOrigin.carry_local_mark(scope, scope.with_local(name, type), name, optimistic)
         end
       end
 
+      # An ivar on its ADR-58 declaration seed reaches {.bind} through {.reflective_unknown_ivars}, and through
+      # `ExpressionTyper#prefix_answered_scope`; rebinding it re-stamps the declaration mark, as
+      # `ReflectiveIvarWrite.apply` does, so a nil in the seed fuels no nil-receiver diagnostic.
+      def bind_ivar(scope, name, type, optimistic)
+        bound = OptimisticOrigin.carry_ivar_mark(scope, scope.with_ivar(name, type), name, optimistic)
+        scope.declaration_sourced?(:ivar, name) ? bound.seed_declaration_sourced_ivar(name, type) : bound
+      end
+
       # The optimistic nil-freeness mark `scope` holds for a name from {.writes}, or nil.
       def optimistic_mark(scope, name)
         case variable_kind(name)
@@ -290,7 +344,7 @@ module Rigor
         receiver = node.receiver
         return true if receiver && MutationWidening::SHAPE_MUTATORS.include?(node.name)
 
-        callee_call?(node)
+        ReflectiveIvarWrite.self_write?(node) || callee_call?(node)
       end
 
       # Issue #1412 — {.content_mutations} for a `while` / `until` / `for` body: the locals bound in `base_scope`

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

@@ -39,6 +39,9 @@ module Rigor
       Hit = Data.define(:answer, :owner, :index, :side)
 
       QUESTIONS = %i[definer visibility arity override own_side].freeze
+      # The questions whose answer reads a recorded visibility: only they treat a contested visibility slot as a
+      # possible definer ({#possible?}).
+      VISIBILITY_QUESTIONS = %i[visibility override].freeze
       NONE = :rigor_definer_resolution_none
       STRAY = :rigor_definer_resolution_stray
       private_constant :NONE, :STRAY
@@ -58,12 +61,13 @@ module Rigor
         flavor = question == :arity ? :arity : :methods
         chain = Scope::ResolutionChain.for(scope, class_name.to_s, side, flavor)
 
-        hits = candidates(scope, chain, method_name, from, answer_in)
+        reads_visibility = VISIBILITY_QUESTIONS.include?(question) ? question : nil
+        hits = candidates(scope, chain, method_name, from, answer_in, reads_visibility)
         return UNKNOWN if hits.nil?
 
         verdict = chain.settle(scope, outcomes(hits), owner: hits.first&.owner, unknown_for: method_name) do |retro|
           retro_from = retro_position(chain, retro, from)
-          outcomes(retro_from && candidates(scope, retro, method_name, retro_from, answer_in))
+          outcomes(retro_from && candidates(scope, retro, method_name, retro_from, answer_in, reads_visibility))
         end
         return UNKNOWN unless verdict == :chain
         return UNKNOWN if side == :singleton && SingletonHookDecline.decline?(scope, chain, method_name, from, hits)
@@ -101,7 +105,7 @@ module Rigor
       # follows (the absent candidate). A cut chain, and a chain on which an external ancestor ahead of the
       # candidate (or, with no candidate, the implicit `Object`) may define the name, is a decline, answered by
       # nil instead of a set.
-      def candidates(scope, chain, method_name, from, answer_in)
+      def candidates(scope, chain, method_name, from, answer_in, reads_visibility)
         hits = []
         position = from
         loop do
@@ -113,7 +117,9 @@ module Rigor
           return nil if hit.nil? && chain.truncated?
 
           hits << hit
-          return decided(scope, chain, method_name, from, hits) if hit.nil? || !possible?(scope, hit, method_name)
+          if hit.nil? || !possible?(scope, hit, method_name, reads_visibility)
+            return decided(scope, chain, method_name, from, hits)
+          end
 
           position = hit.index + 1
         end
@@ -153,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.
@@ -188,15 +210,27 @@ module Rigor
       end
 
       # A definer that rests on a fact the walk could not prove executes: the member's `possible` sibling, or a
-      # contested slot of one of the single-valued members.
-      def possible?(scope, hit, method_name)
+      # contested slot of one of the single-valued members. A contested visibility slot counts only for a question
+      # 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]) ||
-          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
 
@@ -226,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))
 
-            scope.discovered_method_visibility(entry.name, method_name) || :public
+            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
+
+      # 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
@@ -256,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