rigortype 0.4.6 → 0.4.8

data/lib/rigor/inference/optimistic_origin.rb

@@ -2,6 +2,8 @@
 
 require "prism"
 
+require_relative "../type"
+
 module Rigor
   module Inference
     # Marks a value whose *nil-freeness* rests on Rigor's deliberate choice to ignore core RBS's
@@ -18,7 +20,7 @@ module Rigor
     # that happens to have been produced optimistically.
     #
     # Issue #286: the `if` / `unless` branch elision is one consumer of `Narrowing.predicate_certainty`; the
-    # other two are `flow.always-truthy-condition` and the `&&` / `||` `constant_value_polarity` gate, and the
+    # other two are `flow.always-truthy-condition` and `StatementEvaluator#right_operand_dead?`, and the
     # spec passage above binds all three. This channel is what lets a certainty judgment tell the two apart.
     #
     # Issue #313: the mark is attached to a *value* — the call node that produced it, or the local / ivar it
@@ -102,24 +104,147 @@ module Rigor
       # `StatementEvaluator` and `AlwaysTruthyConditionCollector` all route here, so the three consumers the
       # spec binds cannot drift apart.
       #
-      # Resolution order — the mark recorded on the node itself, then the binding a bare local / ivar read (or
-      # a write in value position, `if (x = MAP[k])`) resolves through, then a safe-navigation call and the
-      # predicate-fold derivation issue #313 added.
+      # Resolution order — the mark recorded on the node itself, then the binding a bare local / ivar read resolves
+      # through, then a write in value position and a safe-navigation call and the predicate-fold derivation issue
+      # #313 added.
       def resolve(node, scope)
         return nil if node.nil? || scope.nil?
 
-        recorded = scope.optimistic_origins[node]
+        recorded = scope.optimistic_origin(node)
         return recorded if recorded
 
+        resolve_node(node, scope)
+      end
+
+      # The shape dispatch {.resolve} applies once the node-level mark is ruled out.
+      def resolve_node(node, scope)
         case node
-        when Prism::LocalVariableReadNode, Prism::LocalVariableWriteNode then scope.optimistic_local(node.name)
-        when Prism::InstanceVariableReadNode, Prism::InstanceVariableWriteNode then scope.optimistic_ivar(node.name)
+        when Prism::LocalVariableReadNode then scope.optimistic_local(node.name)
+        when Prism::InstanceVariableReadNode then scope.optimistic_ivar(node.name)
+        when Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode,
+             Prism::GlobalVariableWriteNode, Prism::ClassVariableWriteNode,
+             Prism::MultiWriteNode, Prism::LocalVariableOrWriteNode,
+             Prism::InstanceVariableOrWriteNode, Prism::ClassVariableOrWriteNode,
+             Prism::GlobalVariableOrWriteNode, Prism::LocalVariableAndWriteNode,
+             Prism::InstanceVariableAndWriteNode, Prism::ClassVariableAndWriteNode,
+             Prism::GlobalVariableAndWriteNode
+          resolve_write_form(node, scope)
         when Prism::AndNode, Prism::OrNode then resolve(node.left, scope) || resolve(node.right, scope)
-        when Prism::CallNode then resolve_through_safe_navigation(node, scope) || resolve_through_predicate(node, scope)
+        when Prism::CallNode
+          resolve_attribute_write(node, scope) || resolve_through_safe_navigation(node, scope) ||
+            resolve_through_predicate(node, scope)
         when Prism::ParenthesesNode then resolve_through_parentheses(node, scope)
         end
       end
 
+      # The write forms in value position: the plain and multiple writes whose value is the
+      # right-hand side, and the `||=` / `&&=` spellings whose old binding participates.
+      def resolve_write_form(node, scope)
+        case node
+        when Prism::LocalVariableOrWriteNode, Prism::InstanceVariableOrWriteNode,
+             Prism::ClassVariableOrWriteNode, Prism::GlobalVariableOrWriteNode
+          resolve_or_write(node, scope)
+        when Prism::LocalVariableAndWriteNode, Prism::InstanceVariableAndWriteNode,
+             Prism::ClassVariableAndWriteNode, Prism::GlobalVariableAndWriteNode
+          resolve_and_write(node, scope)
+        else
+          resolve_write(node, scope)
+        end
+      end
+
+      # Issue #2617 — a write in value position (`if (v = h[k])`) yields its right-hand side, so the write's own
+      # optimism is the RHS's. The binding lookup alone could not see it from the scope a certainty consumer
+      # reads: the `if`'s entry scope predates the predicate's evaluation, so `if (v = h[k])` found no mark for
+      # `v` there and `flow.always-truthy-condition` fired on the optimistic read. Resolving `node.value` reaches
+      # the mark recorded on the read itself, which lives in the side table every scope shares; the binding lookup
+      # stays as the fallback for the post-write scope `branch_certainty` passes.
+      def resolve_write(node, scope)
+        resolve(node.value, scope) || optimistic_write_binding(node, scope)
+      end
+
+      # Only locals and ivars carry a binding mark; a global or class-variable write, and a
+      # multiple assignment's slots (marked through {.destructuring_marks} instead), have no
+      # `optimistic_*` table entry to fall back to, so they answer nil here.
+      def optimistic_write_binding(node, scope)
+        case node
+        when Prism::LocalVariableWriteNode then scope.optimistic_local(node.name)
+        when Prism::InstanceVariableWriteNode then scope.optimistic_ivar(node.name)
+        end
+      end
+
+      # Issue #3054 — `v ||= rhs` yields the OLD binding whenever it is truthy, so the write's
+      # value is the right-hand side's only on the paths where the old value is falsey. When the
+      # old binding is provably always truthy — its type has no falsey inhabitant and it carries
+      # no optimistic mark — the right-hand side is never reached and the expression's verdict is
+      # the old value's own proof, so resolving through `node.value` would silence a correct
+      # always-truthy verdict (`v = "x"; if (v ||= h[k])` still folds to `"x"`). Otherwise the
+      # verdict, when one folds, rests on the right-hand side's bet.
+      def resolve_or_write(node, scope)
+        binding_type, binding_mark = or_write_binding(node, scope)
+        return nil if always_truthy_type?(binding_type) && binding_mark.nil?
+
+        resolve(node.value, scope)
+      end
+
+      # Issue #3054 — `v &&= rhs` yields the right-hand side whenever the old binding is truthy;
+      # the old value itself wins only on its falsey edge, a result no always-truthy verdict can
+      # rest on. So the right-hand side's mark covers every constant verdict the expression folds
+      # to, joined by the old binding's own mark for the case where the miss — not the rvalue — is
+      # what makes the condition live (`v = h[k]; if (v &&= "lit")`).
+      def resolve_and_write(node, scope)
+        resolve(node.value, scope) || and_write_binding_mark(node, scope)
+      end
+
+      # The `[type, mark]` pair an `||=` reads its old value through: the scope binding and the
+      # optimistic mark it carries. Class- and global-variable or-writes have no mark table — the
+      # mark channel covers locals and ivars only — so their mark is always nil.
+      def or_write_binding(node, scope)
+        case node
+        when Prism::LocalVariableOrWriteNode
+          [scope.local(node.name), scope.optimistic_local(node.name)]
+        when Prism::InstanceVariableOrWriteNode
+          [scope.ivar(node.name), scope.optimistic_ivar(node.name)]
+        when Prism::ClassVariableOrWriteNode
+          [scope.cvar(node.name), nil]
+        when Prism::GlobalVariableOrWriteNode
+          [scope.global(node.name), nil]
+        end
+      end
+
+      # The old binding's optimistic mark for an `&&=` — the same two tables {.or_write_binding}
+      # reads, with no type: `&&=` needs the mark alone.
+      def and_write_binding_mark(node, scope)
+        case node
+        when Prism::LocalVariableAndWriteNode then scope.optimistic_local(node.name)
+        when Prism::InstanceVariableAndWriteNode then scope.optimistic_ivar(node.name)
+        end
+      end
+
+      # Issue #3054 — `recv.x = rhs` and `recv[i] = rhs` yield the assigned value, which Prism
+      # spells as the call's last argument (`x=` takes it alone, `[]=` trails the indices). The
+      # compound spellings never reach here: `+=` / `[]=` operators and `||=` / `&&=` on an
+      # attribute or index are `CallOperatorWriteNode` / `IndexOperatorWriteNode` /
+      # `CallOrWriteNode` / `CallAndWriteNode` / `IndexOrWriteNode` / `IndexAndWriteNode`, not
+      # `CallNode`, and their value is the old slot's, not the right-hand side's.
+      def resolve_attribute_write(node, scope)
+        resolve(node.arguments&.arguments&.last, scope) if node.attribute_write?
+      end
+
+      # Whether `type` proves every inhabitant truthy — the empty falsey fragment of
+      # `Narrowing.narrow_falsey`, mirrored carrier for carrier so this leaf module need not
+      # require `Narrowing` (which already requires this file). A `nil` binding (unbound) and
+      # every carrier the falsey fragment cannot empty (`Top`, `Dynamic`, ranges, refinements,
+      # differences) answer false: only a proof counts.
+      def always_truthy_type?(type)
+        case type
+        when Type::Constant then !(type.value.nil? || type.value == false)
+        when Type::Nominal then !%w[NilClass FalseClass].include?(type.class_name)
+        when Type::Union then type.members.all? { |member| always_truthy_type?(member) }
+        when Type::Singleton, Type::Tuple, Type::HashShape then true
+        else type.is_a?(Type::Bot)
+        end
+      end
+
       # `recv&.m` is `nil` exactly when `recv` is (or when `m` answers `nil`), so it restates `recv`'s presence
       # and is as optimistic as `recv`. Only the call carrying the `&.` is derived: Ruby skips that one call and
       # no more, so `recv&.m.n` sends `n` to the `nil` and raises (or answers `NilClass#n`), and neither it nor
@@ -169,7 +294,7 @@ module Rigor
       # predicate's folded boolean only when the miss answers the other boolean (or cannot be told), so
       # `!recv&.empty?` — `!false` on a hit, `!nil` on a miss — stays `true`, and so does `x = recv&.empty?; !x`.
       def miss_answer(node, scope)
-        return nil if scope.optimistic_origins[node]
+        return nil if scope.optimistic_origin(node)
 
         case node
         when Prism::LocalVariableReadNode then scope.optimistic_local_miss(node.name)

data/lib/rigor/inference/origin_lookup.rb

@@ -23,7 +23,7 @@ module Rigor
       def origin_for(scope, node)
         return nil if node.nil?
 
-        scope.dynamic_origins[node] || propagated(scope, node)
+        scope.dynamic_origin(node) || propagated(scope, node)
       end
 
       def propagated(scope, node)

data/lib/rigor/inference/out_buffer_mutation.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "mutation_widening"
+require_relative "receiver_alias"
+require_relative "../type"
+
+module Rigor
+  module Inference
+    # Issue #2499 rule 3 (part of #2494) — the stdlib calls that fill a String the caller passes in. After
+    # `io.read(n, buf)`, `io.readpartial(n, buf)`, `io.sysread(n, buf)` and `io.read_nonblock(n, buf)` the buffer
+    # holds what was read, and after `StringIO.new(s)` every later write through the StringIO lands in `s`. The
+    # argument (a local, instance, class or global variable read) is widened as an in-place `replace` of it would
+    # widen it, so a `buf = +""` seed stops reading `""` after the call.
+    #
+    # A built-in catalogue keyed by method name and argument position, not a receiver-typed dispatch: a method of
+    # another class with the same name and a second positional argument loses only precision on that argument.
+    module OutBufferMutation
+      # Method name => the zero-based position of the buffer argument.
+      READERS = { read: 1, readpartial: 1, sysread: 1, read_nonblock: 1 }.freeze
+      private_constant :READERS
+
+      module_function
+
+      # `scope` with the buffer argument of `call_node` widened, or `scope` itself when the call is no such call or the
+      # argument holds no String: `Rails.cache.read(key, opts)` passes an options Hash that keeps its shape.
+      def floor(call_node, scope)
+        buffer = buffer_argument(call_node)
+        return scope if buffer.nil?
+
+        getter, = MutationWidening::ALIAS_ACCESSORS[buffer.class]
+        return scope unless string_carrier?(scope.public_send(getter, ReceiverAlias.read_name(buffer)))
+
+        MutationWidening.widen_alias_read(:replace, buffer, scope)
+      end
+
+      # A `Constant<String>` or the `String` nominal, or a union of nothing else.
+      def string_carrier?(type)
+        case type
+        when Type::Constant then type.value.is_a?(String)
+        when Type::Nominal then type.class_name == "String"
+        when Type::Union then type.members.all? { |member| string_carrier?(member) }
+        else false
+        end
+      end
+
+      def buffer_argument(call_node)
+        arguments = call_node.arguments&.arguments
+        return nil if arguments.nil?
+
+        position = READERS[call_node.name]
+        position = 0 if position.nil? && string_io_new?(call_node)
+        return nil if position.nil?
+
+        argument = arguments[position]
+        MutationWidening::ALIAS_ACCESSORS.key?(argument.class) ? argument : nil
+      end
+
+      def string_io_new?(call_node)
+        return false unless call_node.name == :new
+
+        receiver = call_node.receiver
+        case receiver
+        when Prism::ConstantReadNode then receiver.name == :StringIO
+        when Prism::ConstantPathNode then receiver.parent.nil? && receiver.name == :StringIO
+        else false
+        end
+      end
+      private_class_method :buffer_argument, :string_io_new?, :string_carrier?
+    end
+  end
+end

data/lib/rigor/inference/parameter_inference_collector.rb

@@ -95,11 +95,10 @@ module Rigor
     # may type in a later round once its own argument resolves). Unresolved call sites do not
     # contribute.
     #
-    # What it does NOT do yet (deferred — the check-wiring slice): feeding the table into the
-    # `check` walk (only `coverage --protection` consumes it today), keyword / optional / rest
-    # / block parameters, inherited-method receivers, top-level helpers, and a rigorous
-    # closed-call-site-set proof (the union is optimistic over resolved sites — acceptable
-    # because the only consumer is the protection metric, which runs no diagnostics).
+    # What it does NOT do yet: typing keyword / optional / rest / block parameters themselves,
+    # inherited-method receivers, top-level helpers, and a rigorous closed-call-site-set proof
+    # (the union is optimistic over resolved sites; the `check` walk tolerates that because an
+    # inferred parameter is only a lower bound, which the in-body rules decline on, WD6b).
     class ParameterInferenceCollector
       EMPTY = {}.freeze
 
@@ -120,7 +119,7 @@ module Rigor
       # @param files — project `.rb` paths to scan for call sites.
       # @param target_ruby — Prism parse target.
       # @param max_rounds — the WD5 fixpoint cap (1 = single-level).
-      # @return => Hash{Symbol => Rigor::Type}}] frozen.
+      # @return the inferred parameter table, frozen.
       def self.collect(files:, environment:, target_ruby: nil, max_rounds: DEFAULT_ROUNDS, workers: 0)
         new(files: files, environment: environment, target_ruby: target_ruby,
             max_rounds: max_rounds, workers: workers).collect

data/lib/rigor/inference/pre_eval_constants.rb

@@ -13,7 +13,7 @@ module Rigor
     #
     # ADR-17 slice 2 gave `pre_eval:` a project-wide **method** registry ({ProjectPatchedMethods}). A
     # constant declared in the same file stayed invisible across the file boundary: `Scope#in_source_constants`
-    # is per-file and is deliberately not part of `Runner#project_scope_seed_tables`, so only class-shaped
+    # was per-file and kept out of `Runner#project_scope_seed_tables`, so only class-shaped
     # constants (a `class` / `module` declaration, or one of the four meta-new forms `ScopeIndexer`'s
     # `record_class_new_constant_decl` promotes) ever crossed. `TIMEOUT = 30` in a listed file read as
     # `Dynamic[top]` everywhere else.

data/lib/rigor/inference/precision_scanner.rb

@@ -168,7 +168,7 @@ module Rigor
       end
 
       def classify_dynamic(type)
-        type.static_facet.is_a?(Type::Top) ? :dynamic_top : :dynamic_specific
+        Type::Combinator.untyped?(type) ? :dynamic_top : :dynamic_specific
       end
 
       def worst_of(members)

data/lib/rigor/inference/project_method_ownership.rb

@@ -2,6 +2,8 @@
 
 require_relative "../type"
 require_relative "external_ancestor_resolution"
+require_relative "../typing_state"
+require_relative "../memo_audit"
 
 module Rigor
   module Inference
@@ -19,8 +21,14 @@ module Rigor
       NO_TARGETS = [].freeze
       private_constant :NO_TARGETS
 
-      MEMO_KEY = :__rigor_project_method_ownership_memo__
-      private_constant :MEMO_KEY
+      # ADR-129 WD1 — a run-scoped Memo keyed on the identity of the discovery index and the environment, the only
+      # inputs the buckets' answers read.
+      MEMO = TypingState.memo(
+        :project_method_ownership,
+        run_scoped: true, audit: ["project method defines", "block runs", "ancestry non-escaping"],
+        reason: "answer buckets keyed on the discovery index and environment identities"
+      )
+      private_constant :MEMO
 
       module_function
 
@@ -61,9 +69,15 @@ module Rigor
         return false if scope.nil?
 
         by_method = (memo(scope)[kind][class_name] ||= {})
-        return by_method[method_sym] if by_method.key?(method_sym)
+        if by_method.key?(method_sym)
+          return MemoAudit.check("project method defines", by_method[method_sym], class_name, method_sym) do
+            compute_defines?(class_name, method_sym, kind, scope)
+          end
+        end
 
-        by_method[method_sym] = compute_defines?(class_name, method_sym, kind, scope)
+        by_method[method_sym] = MemoAudit.key_audit("project method defines") do
+          compute_defines?(class_name, method_sym, kind, scope)
+        end
       end
 
       # One slot per thread, keyed on the identity of the scope's frozen discovery index and its environment —
@@ -71,15 +85,19 @@ module Rigor
       # changes: the shape of `ExpressionTyper#class_graph_buckets`, whose rationale applies unchanged. A
       # `Scope` merges each file's discovery with the project pre-pass, so the slot turns over per file, and
       # an ADR-46 dependency the first lookup recorded belongs to the file every later hit serves. Pool
-      # workers are separate processes, and a Ractor has its own `Thread.current`. The `:ancestry` bucket
-      # belongs to {ClosureEscapeAnalyzer}'s ancestry step.
+      # workers are separate processes, and a Ractor has its own {TypingState}. The `:ancestry` bucket
+      # belongs to {ClosureEscapeAnalyzer}'s ancestry step. The `:block_runs` bucket belongs to
+      # {BlockRunCount}.
       def memo(scope)
+        return new_buckets if MemoAudit.enabled? && MemoAudit.suspended?
+
         discovery = scope.discovery
         environment = scope.environment
-        slot = Thread.current[MEMO_KEY]
+        state = TypingState.current
+        slot = state[MEMO]
         unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
-          slot = [discovery, environment, { instance: {}, singleton: {}, ancestry: {} }]
-          Thread.current[MEMO_KEY] = slot
+          slot = [discovery, environment, new_buckets]
+          state[MEMO] = slot
         end
         slot[2]
       end
@@ -87,6 +105,9 @@ module Rigor
       class << self
         private
 
+        # Empty buckets: a new slot's, and a throwaway set while an audit recomputation bypasses the memo.
+        def new_buckets = { instance: {}, singleton: {}, ancestry: {}, block_runs: {}.compare_by_identity }
+
         def class_target(class_name, kind)
           class_name.nil? ? nil : [[class_name.to_s, kind]]
         end

data/lib/rigor/inference/project_patched_methods.rb

@@ -36,6 +36,9 @@ module Rigor
       # `farther` is set only on an entry {#lookup_through_ancestors} returns: the other definers of the name farther
       # on the walk (entries, or {SOURCE_DEFINER} for a project-source `def`), which {#callable?} reads before it
       # refuses the call.
+      #
+      # `kind` stays truthful on a copy {#singleton_copy_entry} returns: the `module_function` singleton copy is a
+      # `:singleton` method even though the body it copied is an instance `def`.
       Entry = Data.define(:class_name, :method_name, :kind, :source_path, :source_line, :return_type, :alias_of,
                           :visibility, :farther) do
         def initialize(class_name:, method_name:, kind:, source_path:, source_line:, return_type: nil, alias_of: nil,
@@ -49,7 +52,7 @@ module Rigor
       # written, with no lexical resolution, as a patch's class name is.
       Mixin = Data.define(:owner, :module_name, :kind)
 
-      attr_reader :by_key, :write_census, :mixins, :overrides
+      attr_reader :by_key, :write_census, :mixins, :overrides, :singleton_copies
 
       # Each owner's prepended and included modules, the most recent first.
       def self.mixins_by_owner(mixins)
@@ -69,7 +72,12 @@ module Rigor
       # @param overrides — issue #1708: `[class_name, method_name, kind] => visibility` for a named visibility call
       #   (`public :kp` in `class Integer`) on a method the class inherits rather than binds, which Ruby copies onto
       #   the class with that visibility.
-      def initialize(entries: [], write_census: GlobalWriteCensus::EMPTY, mixins: [], overrides: {})
+      # @param singleton_copies — issue #2108: `[class_name, method_name]` pairs a `module_function :x` wrote for a
+      #   name the class inherits rather than binds — Ruby's public singleton copy of the instance method the name
+      #   resolves to. {#lookup_through_ancestors} answers a singleton-side call for one through
+      #   {#singleton_copy_entry}.
+      def initialize(entries: [], write_census: GlobalWriteCensus::EMPTY, mixins: [], overrides: {},
+                     singleton_copies: [])
         @by_key = entries.each_with_object({}) do |entry, acc|
           key = [entry.class_name, entry.method_name, entry.kind]
           acc[key] = entry
@@ -78,6 +86,7 @@ module Rigor
         @mixins = mixins.dup.freeze
         @mixins_of = ProjectPatchedMethods.mixins_by_owner(@mixins)
         @overrides = overrides.dup.freeze
+        @singleton_copies = singleton_copies.to_set.freeze
         freeze
       end
 
@@ -121,10 +130,18 @@ module Rigor
           end
 
           entry = @by_key[[owner, method_name, side]]
+          if entry.nil? && found.nil? && side == :singleton
+            copy = singleton_copy_entry(owner, method_name, rbs_loader, source_defines)
+            # Issue #2108 — a singleton copy is a real method on `#<Class:owner>` at this exact ancestor
+            # position: Ruby's lookup ends there, so nothing farther on the walk can answer `owner.x`.
+            # Return it now — collecting `farther` would only make {#callable?} decline the refusal Ruby
+            # makes of a private or protected copy.
+            return apply_override(copy, override) if copy
+          end
           if found
             farther << entry if entry
           elsif entry
-            found = override ? entry.with(class_name: override.first, visibility: override.last) : entry
+            found = apply_override(entry, override)
           elsif (visibility = @overrides[[owner, method_name, side]])
             override ||= [owner, visibility]
           end
@@ -137,9 +154,12 @@ module Rigor
 
       # Issue #1708 — whether Ruby lets a call reach `entry`. A public method answers any call; a private one only a
       # call with no receiver or with `self` as it (`explicit` is false for those); a protected one also a call from
-      # a method whose `self` is an instance of the entry's owner. `self_type` is the caller's `self` (`nil` at the
-      # top level, where it is `main`, an Object); a `self` this cannot name (the default) may be one, so a
-      # protected entry answers it.
+      # a method whose `self` is an instance of the entry's owner — for a `:singleton` entry, the owner itself or a
+      # class whose singleton chain holds it (`Kernel.a1` under `class << self; protected :a1` is refused from
+      # `main`, an Object, and from another class's singleton method, and answered from Kernel's own and from a
+      # `module_function` def of Kernel's, whose self is typed as an instance of Kernel though the copy runs with
+      # self = Kernel). `self_type` is the caller's `self` (`nil` at the top level, where it is `main`, an Object);
+      # a `self` this cannot name (the default) may be one, so a protected entry answers it.
       #
       # It never refuses a call some other definer of the name may answer: the walk's order is an approximation
       # (a module two owners mix in is spliced at the nearer one, where Ruby keeps the first include and skips the
@@ -152,7 +172,7 @@ module Rigor
         allowed =
           case entry.visibility
           when :private, :module_function then false
-          when :protected then self_kind_of?(self_type, entry.class_name, rbs_loader)
+          when :protected then self_kind_of?(self_type, entry.class_name, entry.kind, rbs_loader)
           else true
           end
         return true if allowed
@@ -171,18 +191,50 @@ module Rigor
 
       private
 
-      # Whether `self_type` may be an instance of `owner`: false only when the ancestors of a class RBS knows,
-      # with the patches' mixins, do not hold it.
-      def self_kind_of?(self_type, owner, rbs_loader)
-        name, kind =
+      # Whether `self_type` may reach `owner`'s `entry_kind` method: false only when the ancestors of a class RBS
+      # knows, with the patches' mixins, do not hold `[owner, entry_kind]` — an instance of the owner for an
+      # instance method, the owner itself or a class whose singleton chain holds it for a singleton one. For a
+      # singleton entry a self whose class IS the owner answers too: a `module_function` / `extend self` def is
+      # typed `Nominal[owner]` though its singleton copy runs with self = owner, so `name == owner` may be the
+      # owner object itself (issue #3056).
+      def self_kind_of?(self_type, owner, entry_kind, rbs_loader)
+        name, side =
           if self_type.nil? then ["Object", :instance]
           elsif self_type.respond_to?(:class_name) && self_type.class_name
             [self_type.class_name.to_s, self_type.is_a?(Type::Singleton) ? :singleton : :instance]
           end
         return true if name.nil? || rbs_loader.nil?
 
-        keys = ancestor_keys(name, kind, rbs_loader)
-        keys == [[name, kind]] || keys.include?([owner, :instance])
+        keys = ancestor_keys(name, side, rbs_loader)
+        keys == [[name, side]] || keys.include?([owner, entry_kind]) ||
+          (entry_kind == :singleton && side == :instance && name == owner)
+      end
+
+      # `entry` as the walk's recorded `override` ([owner, visibility], from a nearer row's named
+      # visibility call) leaves it: the override's owner as `class_name` and its visibility — or `entry`
+      # itself when the walk passed no override on the way.
+      def apply_override(entry, override)
+        override ? entry.with(class_name: override.first, visibility: override.last) : entry
+      end
+
+      # Issue #2108 — the entry a `module_function :x` on a name `owner` inherits answers `owner.x` with. Ruby
+      # copies the instance method the name resolves to onto the owner's singleton as a public method, so the
+      # copy is the entry this walk finds for the name on the owner's INSTANCE ancestors, re-attributed to the
+      # owner, re-kinded `:singleton` and made public — unless a later named visibility call (`private_class_method
+      # :x`, or `private :x` in `class << self`) recorded the pair's singleton-side override, which Ruby applies to
+      # the copy. The instance walk's `farther` definers are dropped: the copy is a real method on
+      # `#<Class:owner>` that ends the singleton-side lookup, so no instance-chain definer can answer `owner.x`,
+      # and keeping them would only make {#callable?} decline a refusal Ruby makes. nil when no copy is
+      # recorded for `[owner, method_name]`, or when the instance walk finds no patch entry — an RBS or
+      # project-source method the registry does not hold, where the singleton walk then answers whatever else
+      # it reaches, as before.
+      def singleton_copy_entry(owner, method_name, rbs_loader, source_defines)
+        return nil unless @singleton_copies.include?([owner, method_name])
+
+        copy = lookup_through_ancestors(class_name: owner, method_name: method_name, kind: :instance,
+                                        rbs_loader: rbs_loader, source_defines: source_defines)
+        copy&.with(class_name: owner, kind: :singleton, farther: nil,
+                   visibility: @overrides[[owner, method_name, :singleton]] || :public)
       end
 
       def ancestor_keys(class_name, kind, rbs_loader)