rigortype 0.4.7 → 0.4.8

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "rbs"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #2828 — how overload selection reads a parameter spelled `singleton(T)` over a method-level type
+      # variable `T`. RBS parses it as a class singleton whose name is the bare, relative `T`, and the
+      # translator reads that as a class named `T`: an unloadable class whose singleton refuses every class object
+      # the analyzer process has loaded (`Acceptance` rules a loaded class out of an unloadable target's
+      # subtypes). With `Resolv` loaded, `Resolv::DNS#getresources: [T < Resource] (dns_name, singleton(T)) ->
+      # Array[T] | ...` then lost to the base overload.
+      #
+      # Selection instead reads the parameter as "a class object" the variable admits: `singleton(X)` for a
+      # class upper bound `X`, and `Module` otherwise, which takes any class or module object and refuses an
+      # instance. Only names the overload declares in its own `type_params` are read this way; any other
+      # unresolved `singleton(X)` keeps the translator's reading.
+      #
+      # {.selecting} hands the selector the overloads rewritten where a parameter needs it and maps the selected
+      # rewrites back, so the return translation and the argument binding (`RbsDispatch#singleton_param_binding`)
+      # still read the declared `singleton(T)`.
+      module SingletonTypeParams
+        module_function
+
+        # Yields the overloads to select among and answers the block's selection, with each rewrite mapped back to
+        # its declaration. Nearly every method needs no rewrite, and then `declared` is yielded as is.
+        def selecting(declared)
+          return yield(declared) unless declared.any? { |method_type| rewrites?(method_type) }
+
+          originals = {}.compare_by_identity
+          rewritten = declared.map do |method_type|
+            next method_type unless rewrites?(method_type)
+
+            rewrite = rewrite(method_type)
+            originals[rewrite] = method_type
+            rewrite
+          end
+          yield(rewritten).map { |method_type| originals.fetch(method_type, method_type) }
+        end
+
+        def rewrites?(method_type)
+          params = method_type.respond_to?(:type_params) ? method_type.type_params : nil
+          return false if params.nil? || params.empty?
+
+          fun = method_type.type
+          return false unless fun.respond_to?(:required_positionals)
+
+          any_variable_singleton?(fun.required_positionals, params) ||
+            any_variable_singleton?(fun.optional_positionals, params) ||
+            any_variable_singleton?(fun.trailing_positionals, params)
+        end
+
+        def any_variable_singleton?(list, type_params)
+          list.any? { |param| variable_singleton?(param.type, type_params) }
+        end
+
+        def variable_singleton?(type, type_params)
+          return false unless type.is_a?(RBS::Types::ClassSingleton)
+
+          name = type.name
+          return false if name.absolute? || !name.namespace.empty?
+
+          type_params.any? { |type_param| type_param.name == name.name }
+        end
+
+        # One parameter of `method_type` as selection reads it: `call.argument-type-mismatch` checks a call the
+        # same way, and otherwise declines every overload with a `singleton(T)` parameter as naming a class nothing
+        # defines.
+        def selection_param(param, method_type)
+          type_params = method_type.type_params
+          return param unless variable_singleton?(param.type, type_params)
+
+          param.map_type { |type| class_object_type(type.name.name, type_params) }
+        end
+
+        def rewrite(method_type)
+          type_params = method_type.type_params
+          fun = method_type.type.map_type do |type|
+            variable_singleton?(type, type_params) ? class_object_type(type.name.name, type_params) : type
+          end
+          RBS::MethodType.new(type_params: type_params, type: fun, block: method_type.block,
+                              location: method_type.location)
+        end
+
+        # Built per rewrite rather than held in a constant: an RBS type is not `Ractor.shareable?` (#1064), and a
+        # rewrite happens only for the few overloads that spell `singleton(T)`.
+        def module_type
+          RBS::Types::ClassInstance.new(
+            name: RBS::TypeName.new(name: :Module, namespace: RBS::Namespace.root), args: [], location: nil
+          )
+        end
+
+        def class_object_type(name, type_params)
+          type_param = type_params.find { |tp| tp.name == name }
+          bound = type_param.upper_bound
+          return module_type unless bound.is_a?(RBS::Types::ClassInstance)
+
+          RBS::Types::ClassSingleton.new(name: bound.name, location: nil)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../reflection"
+require_relative "../typing_state"
 require_relative "../type"
 require_relative "../flow_contribution"
 require_relative "../flow_contribution/merger"
@@ -18,6 +19,7 @@ require_relative "method_dispatcher/shape_dispatch"
 require_relative "method_dispatcher/data_folding"
 require_relative "method_dispatcher/struct_folding"
 require_relative "method_dispatcher/rbs_dispatch"
+require_relative "method_dispatcher/declared_constructor"
 require_relative "method_dispatcher/iterator_dispatch"
 require_relative "method_dispatcher/arithmetic_sequence_elements"
 require_relative "method_dispatcher/reduce_folding"
@@ -195,7 +197,7 @@ module Rigor
         rbs_result = RbsDispatch.try_dispatch(context)
         if rbs_result
           record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
-          if rbs_result.is_a?(Type::Dynamic) && rbs_result.static_facet.is_a?(Type::Top)
+          if Type::Combinator.untyped?(rbs_result)
             scope&.record_dynamic_origin(call_node, DynamicOrigin::EXPLICIT_UNTYPED)
           end
           return rbs_result
@@ -826,7 +828,7 @@ module Rigor
       end
 
       def rbs_result_untyped?(rbs_result)
-        rbs_result.is_a?(Type::Dynamic) && rbs_result.static_facet.is_a?(Type::Top)
+        Type::Combinator.untyped?(rbs_result)
       end
 
       def rbs_display_for(rbs_result)
@@ -1070,13 +1072,29 @@ module Rigor
         scope = context.scope
         return false if scope.nil?
 
+        class_name = receiver_type.class_name
+        method_name = context.method_name
+        if MemoAudit.enabled? && MemoAudit.suspended?
+          return external_ancestor_declares?(class_name, method_name, scope,
+                                             environment)
+        end
+
         memo = external_ancestor_memo(scope, environment)
-        key = [receiver_type.class_name, context.method_name]
-        return memo[key] if memo.key?(key)
+        key = [class_name, method_name]
+        if memo.key?(key)
+          return MemoAudit.check("user class fallback external ancestor", memo[key], class_name, method_name) do
+            external_ancestor_declares?(class_name, method_name, scope, environment)
+          end
+        end
+
+        memo[key] = MemoAudit.key_audit("user class fallback external ancestor") do
+          external_ancestor_declares?(class_name, method_name, scope, environment)
+        end
+      end
 
-        memo[key] = !ExternalAncestorResolution.resolve(receiver_type.class_name, context.method_name, :instance,
-                                                        scope: scope, environment: environment,
-                                                        record_dependencies: false).nil?
+      def external_ancestor_declares?(class_name, method_name, scope, environment)
+        !ExternalAncestorResolution.resolve(class_name, method_name, :instance,
+                                            scope: scope, environment: environment, record_dependencies: false).nil?
       end
 
       # Issue #2284 — a class object whose singleton chain holds a project definer of the name (its own `def
@@ -1101,43 +1119,67 @@ module Rigor
       end
 
       def project_defines_name?(scope, method_name)
+        if MemoAudit.enabled? && MemoAudit.suspended?
+          return BlockCallTiming.project_defines_anywhere?(method_name,
+                                                           scope)
+        end
+
         memo = defines_name_memo(scope)
         if memo.key?(method_name)
           Analysis::DependencyRecorder.read_missing(:defines, method_name) if Analysis::DependencyRecorder.active?
-          return memo[method_name]
+          return MemoAudit.check("user class fallback defines name", memo[method_name], method_name) do
+            BlockCallTiming.project_defines_anywhere?(method_name, scope)
+          end
         end
 
-        memo[method_name] = BlockCallTiming.project_defines_anywhere?(method_name, scope)
+        memo[method_name] = MemoAudit.key_audit("user class fallback defines name") do
+          BlockCallTiming.project_defines_anywhere?(method_name, scope)
+        end
       end
 
-      DEFINES_NAME_MEMO_KEY = RunScopedSlots.register(:__rigor_user_class_fallback_defines_name__)
-      private_constant :DEFINES_NAME_MEMO_KEY
+      # ADR-129 WD1 — a run-scoped Memo: one slot keyed on the identity of the discovery index and the environment,
+      # the only inputs the name table's answers read.
+      DEFINES_NAME_MEMO = TypingState.memo(
+        :user_class_fallback_defines_name,
+        run_scoped: true, audit: "user class fallback defines name",
+        reason: "one [discovery, environment, names] slot keyed on the identities of the discovery " \
+                "index and the environment; each name's answer reads only them"
+      )
+      private_constant :DEFINES_NAME_MEMO
 
       # One slot per discovery index and environment, as {#external_ancestor_memo} keeps its own: the answer reads
       # only the frozen discovery tables and the environment's `pre_eval:` patches.
       def defines_name_memo(scope)
         discovery = scope.discovery
         environment = scope.environment
-        slot = Thread.current[DEFINES_NAME_MEMO_KEY]
+        state = TypingState.current
+        slot = state[DEFINES_NAME_MEMO]
         unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
           slot = [discovery, environment, {}]
-          Thread.current[DEFINES_NAME_MEMO_KEY] = slot
+          state[DEFINES_NAME_MEMO] = slot
         end
         slot[2]
       end
 
-      EXTERNAL_ANCESTOR_MEMO_KEY = RunScopedSlots.register(:__rigor_user_class_fallback_external_ancestor__)
-      private_constant :EXTERNAL_ANCESTOR_MEMO_KEY
+      # ADR-129 WD1 — a run-scoped Memo, keyed as {DEFINES_NAME_MEMO} is.
+      EXTERNAL_ANCESTOR_MEMO = TypingState.memo(
+        :user_class_fallback_external_ancestor,
+        run_scoped: true, audit: "user class fallback external ancestor",
+        reason: "one [discovery, environment, answers] slot keyed on the identities of the " \
+                "discovery index and the RBS environment, the only inputs the walk reads"
+      )
+      private_constant :EXTERNAL_ANCESTOR_MEMO
 
       # One slot per discovery index and environment, as `RbsDispatch#ancestor_memo_slot` keeps its own: the answer
       # reads only the frozen discovery tables and the RBS environment, and its walk is withheld from dependency
       # recording, so it may be served again for the same pair.
       def external_ancestor_memo(scope, environment)
         discovery = scope.discovery
-        slot = Thread.current[EXTERNAL_ANCESTOR_MEMO_KEY]
+        state = TypingState.current
+        slot = state[EXTERNAL_ANCESTOR_MEMO]
         unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
           slot = [discovery, environment, {}]
-          Thread.current[EXTERNAL_ANCESTOR_MEMO_KEY] = slot
+          state[EXTERNAL_ANCESTOR_MEMO] = slot
         end
         slot[2]
       end
@@ -1364,7 +1406,13 @@ module Rigor
         class_new_lift = class_new_lift(receiver_type.class_name, arg_types, context)
         return class_new_lift if class_new_lift
 
-        Type::Combinator.nominal_of(receiver_type.class_name)
+        declared_or_nominal(receiver_type.class_name, context)
+      end
+
+      # Issue #2884 — the `meta_new` tail: a declared `def self.new` ({DeclaredConstructor}), else `Nominal[X]`.
+      def declared_or_nominal(class_name, context)
+        declared = context && DeclaredConstructor.try_dispatch(class_name, context)
+        declared || Type::Combinator.nominal_of(class_name)
       end
 
       # `Struct.new(:a, :b)` synthesises an anonymous Struct *subclass* (a class object), not a

data/lib/rigor/inference/method_parameter_binder.rb

@@ -54,6 +54,114 @@ module Rigor
       end
     end
 
+    # Issue #2681 — which declared type, if any, one RBS overload hands a `def`'s parameter slot when the def's shape
+    # need not match the declaration's (an override bound from its ancestor, or a source `def` whose RBS was written
+    # for another shape). A slot takes a type only where the two shapes line up:
+    #
+    # - a leading positional (required or optional) takes the declared leading positional at the same ABSOLUTE
+    #   position, and a post positional the declared trailing one, provided both sides have as many post as
+    #   trailing positionals: Ruby fills the leading parameters left to right on both sides, so the argument a call
+    #   puts at a leading position reaches the slot at the same one;
+    # - `*rest` takes the declared rest only when the def has exactly the declared leading positionals;
+    # - a keyword takes the declared keyword of its name, and `**kw` the declared keyword rest only when the def
+    #   names every declared keyword.
+    #
+    # Any other overlap is {MISALIGNED}, and leaves the slot `Dynamic[Top]`. {NOT_PASSED} is an overload that passes
+    # the slot nothing (`def first(n)` under `Array#first`'s `()`), which the binder skips.
+    module SlotAlignment
+      module_function
+
+      MISALIGNED = :misaligned
+      NOT_PASSED = :not_passed
+
+      # `accepts_keywords` is false for a def with no keyword parameter and no `**`, `**nil` or `...`: Ruby passes a
+      # call's keywords to such a def as a Hash in one more positional argument.
+      Shape = Data.define(:requireds, :leading, :posts, :keywords, :accepts_keywords)
+
+      def shape_of(params_node)
+        return Shape.new(0, 0, 0, [].freeze, false) if params_node.nil?
+
+        requireds = params_node.requireds.size
+        keywords = params_node.keywords.map(&:name).freeze
+        accepts_keywords = !keywords.empty? || !params_node.keyword_rest.nil?
+        Shape.new(requireds, requireds + params_node.optionals.size, params_node.posts.size, keywords,
+                  accepts_keywords)
+      end
+
+      # The RBS type the overload `function` declares for `slot`, {MISALIGNED} or {NOT_PASSED}.
+      def declared(function, slot, shape)
+        return MISALIGNED if keyword_hash_reaches?(function, slot, shape)
+
+        case slot.kind
+        when :required_positional then leading(function, shape, slot.index)
+        when :optional_positional then leading(function, shape, shape.requireds + slot.index)
+        when :trailing_positional then trailing(function, shape, slot.index)
+        when :rest_positional then rest(function, shape)
+        when :required_keyword, :optional_keyword then keyword(function, slot.name)
+        when :rest_keyword then rest_keyword(function, shape)
+        else NOT_PASSED
+        end
+      end
+
+      # Whether the overload's keywords may reach `slot` as a positional Hash: the def accepts no keywords, so a
+      # call's keywords arrive as one more positional argument, which lands past the declared required leading
+      # positionals, in the `*rest`, or (shifting every post positional) in a post positional.
+      def keyword_hash_reaches?(function, slot, shape)
+        return false if shape.accepts_keywords
+        return false if function.required_keywords.empty? && function.optional_keywords.empty? &&
+                        function.rest_keywords.nil?
+
+        case slot.kind
+        when :required_positional then slot.index >= function.required_positionals.size
+        when :optional_positional then shape.requireds + slot.index >= function.required_positionals.size
+        when :rest_positional, :trailing_positional then true
+        else false
+        end
+      end
+
+      def leading(function, shape, position)
+        return MISALIGNED unless function.trailing_positionals.size == shape.posts
+
+        required = function.required_positionals
+        return required[position].type if position < required.size
+
+        optional = function.optional_positionals[position - required.size]
+        return optional.type if optional
+
+        function.rest_positionals ? MISALIGNED : NOT_PASSED
+      end
+
+      def trailing(function, shape, index)
+        return MISALIGNED unless function.trailing_positionals.size == shape.posts
+
+        function.trailing_positionals[index].type
+      end
+
+      def rest(function, shape)
+        return MISALIGNED unless function.trailing_positionals.size == shape.posts
+
+        declared_leading = function.required_positionals.size + function.optional_positionals.size
+        return MISALIGNED if shape.leading < declared_leading
+        return NOT_PASSED if function.rest_positionals.nil?
+
+        shape.leading == declared_leading ? function.rest_positionals.type : MISALIGNED
+      end
+
+      def keyword(function, name)
+        declared = function.required_keywords[name] || function.optional_keywords[name]
+        return declared.type if declared
+
+        function.rest_keywords ? MISALIGNED : NOT_PASSED
+      end
+
+      def rest_keyword(function, shape)
+        declared = function.required_keywords.keys + function.optional_keywords.keys
+        return MISALIGNED unless declared.all? { |name| shape.keywords.include?(name) }
+
+        function.rest_keywords ? function.rest_keywords.type : NOT_PASSED
+      end
+    end
+
     class MethodParameterBinder
       # @param class_path — the qualified name of the class the method is defined in
       #   (e.g., `"Foo::Bar"`), or `nil` for a top-level `def` outside any class. When `nil` (or
@@ -64,11 +172,15 @@ module Rigor
       # @param source_path — the project-relative path of the file the method is
       #   defined in. Used to match ADR-28 path-scoped protocol contracts; `nil` (the default
       #   for synthetic / probe scopes) disables the contract tier.
-      def initialize(environment:, class_path:, singleton:, source_path: nil)
+      # @param scope — the scope the `def` is written in. When supplied, a `def` on a Ruby-source class with no RBS
+      #   of its own binds the parameters of the declaration it overrides on an ADR-43 allow-listed ancestor (#2681);
+      #   `nil` keeps that class's parameters `Dynamic[Top]`.
+      def initialize(environment:, class_path:, singleton:, source_path: nil, scope: nil)
         @environment = environment
         @class_path = class_path
         @singleton = singleton
         @source_path = source_path
+        @scope = scope
       end
 
       # @return ordered map from parameter name to bound type.
@@ -79,7 +191,9 @@ module Rigor
 
         rbs_method = lookup_rbs_method(def_node)
         if rbs_method
-          apply_rbs_overloads(types, slots, rbs_method.method_types) unless rbs_method.method_types.empty?
+          unless rbs_method.method_types.empty?
+            apply_rbs_overloads(types, slots, rbs_method.method_types, SlotAlignment.shape_of(def_node.parameters))
+          end
           # `rigor:v1:param: <name> <refinement>` annotations tighten the bound type for matching
           # slots. Applied after the RBS-overload pass so the override is the authoritative
           # answer regardless of what the RBS signature declared.
@@ -186,15 +300,17 @@ module Rigor
         # `def self.foo` always means a singleton method on the immediate enclosing class. `def
         # foo` inside `class << self` is also a singleton method (the StatementEvaluator threads
         # the `singleton:` flag through this case).
-        if def_node.receiver.is_a?(Prism::SelfNode) || @singleton
-          Rigor::Reflection.singleton_method_definition(@class_path, method_name, environment: @environment)
-        else
-          Rigor::Reflection.instance_method_definition(@class_path, method_name, environment: @environment)
-        end
+        # ADR-43 (#2681) — a source-only subclass of an allow-listed RBS-complete ancestor (`Rigor::Plugin::Base`)
+        # overriding one of its hooks binds the hook's declared parameters, as an empty RBS declaration of the
+        # subclass would through RBS's own inheritance.
+        kind = def_node.receiver.is_a?(Prism::SelfNode) || @singleton ? :singleton : :instance
+        MethodDispatcher::RbsDispatch.def_declaration(@environment, @class_path, kind, method_name, @scope)
       end
 
       # Bind each parameter slot to the union of the matching parameter types across every
-      # overload that *has* that slot. Overloads that omit the slot (e.g., `Array#first` has
+      # overload that *has* that slot, where the def's parameter shape lines up with the overload's
+      # ({SlotAlignment}); one overload that does not line up leaves the slot `Dynamic[Top]`.
+      # Overloads that pass the slot no argument (e.g., `Array#first` has
       # both `()` and `(int)` overloads — only the second matches a `def first(n)` redefinition)
       # are silently skipped, so the binder defaults to the most informative type the RBS
       # signature provides without having to know which overload the runtime will pick.
@@ -203,14 +319,14 @@ module Rigor
       # accepts any argument in every slot, so no slot can be narrowed below `Dynamic[Top]`: binding a typed
       # sibling overload's parameter type would read a value that overload legitimately passes as a
       # contradiction inside the body. Every slot keeps its default; the declared return type still applies.
-      def apply_rbs_overloads(types, slots, method_types)
+      def apply_rbs_overloads(types, slots, method_types, shape)
         return unless method_types.all? { |mt| mt.type.respond_to?(:required_positionals) }
 
         slots.each do |slot|
           next if slot.name.nil?
 
-          translated = collect_translated_types(method_types, slot)
-          next if translated.empty?
+          translated = collect_translated_types(method_types, slot, shape)
+          next if translated.nil? || translated.empty?
 
           types[slot.name] = build_slot_type(translated, slot.kind)
         end
@@ -272,10 +388,15 @@ module Rigor
         slots.find { |slot| POSITIONAL_KINDS.include?(slot.kind) && slot.index == index }
       end
 
-      def collect_translated_types(method_types, slot)
-        rbs_types = method_types.flat_map do |mt|
-          t = rbs_type_for_slot(mt.type, slot)
-          t ? [t] : []
+      # The translated types the overloads declare for `slot`, or nil when one of them does not line up with the
+      # def's parameter shape ({SlotAlignment}): that overload may hand the slot an argument of another type.
+      def collect_translated_types(method_types, slot, shape)
+        rbs_types = []
+        method_types.each do |mt|
+          declared = SlotAlignment.declared(mt.type, slot, shape)
+          return nil if declared.equal?(SlotAlignment::MISALIGNED)
+
+          rbs_types << declared unless declared.equal?(SlotAlignment::NOT_PASSED)
         end
         rbs_types.map { |t| translate_with_self(t) }.uniq
       end
@@ -285,47 +406,6 @@ module Rigor
         wrap_for_kind(bound, kind)
       end
 
-      # Dispatch table from slot kind to a small lambda that pulls the matching RBS parameter
-      # type out of an `RBS::Types::Function`. The hash keeps `rbs_type_for_slot` linear (one
-      # lookup, one call) so the cyclomatic-complexity budget does not balloon as future slices
-      # add more parameter kinds (e.g., `**Symbol kw` is a candidate for a stricter route in
-      # Slice 5+).
-      # Match keyword parameters by name across both required and optional keyword maps. RBS may
-      # declare a keyword as optional (`?by:`) while the Ruby `def` lists it as required (or
-      # vice versa); the binding is by-name regardless of which side defines it.
-      KEYWORD_PROVIDER = Ractor.make_shareable(lambda do |fn, slot|
-        fn.required_keywords[slot.name]&.type || fn.optional_keywords[slot.name]&.type
-      end)
-      private_constant :KEYWORD_PROVIDER
-
-      RBS_TYPE_PROVIDERS = Ractor.make_shareable({
-                                                   required_positional: Ractor.make_shareable(lambda { |fn, slot|
-                                                     fn.required_positionals[slot.index]&.type
-                                                   }),
-                                                   optional_positional: Ractor.make_shareable(lambda { |fn, slot|
-                                                     fn.optional_positionals[slot.index]&.type
-                                                   }),
-                                                   rest_positional: Ractor.make_shareable(lambda { |fn, _slot|
-                                                     fn.rest_positionals&.type
-                                                   }),
-                                                   trailing_positional: Ractor.make_shareable(lambda { |fn, slot|
-                                                     fn.trailing_positionals[slot.index]&.type
-                                                   }),
-                                                   required_keyword: KEYWORD_PROVIDER,
-                                                   optional_keyword: KEYWORD_PROVIDER,
-                                                   rest_keyword: Ractor.make_shareable(lambda { |fn, _slot|
-                                                     fn.rest_keywords&.type
-                                                   })
-                                                 })
-      private_constant :RBS_TYPE_PROVIDERS
-
-      def rbs_type_for_slot(function, slot)
-        provider = RBS_TYPE_PROVIDERS[slot.kind]
-        return nil unless provider
-
-        provider.call(function, slot)
-      end
-
       # The variable bound to a `*rest` parameter is the *Array* of rest-positional arguments,
       # not a single element. Likewise `**kw` is bound to a `Hash[Symbol, V]`. Wrap the
       # translated element/value type accordingly so `rest` reads as `Array[Integer]` rather

data/lib/rigor/inference/module_function_state/spellings.rb

@@ -41,8 +41,8 @@ module Rigor
           any = arguments.empty?
           arguments.each do |arg|
             if arg.is_a?(Prism::DefNode)
-              kind = ScopeIndexer.def_singleton?(arg, qualified_prefix, in_singleton_class) ? :singleton : :both
-              ranges << [arg.location.start_offset, arg.location.end_offset, arg.name, kind, owner]
+              ranges << [arg.location.start_offset, arg.location.end_offset, arg.name,
+                         *ModuleFunctionState.def_row_side(arg, qualified_prefix, in_singleton_class, owner)]
             elsif (name = Source::Literals.symbol_or_string(arg))
               ranges << [*call_span, name, :singleton, owner]
             else

data/lib/rigor/inference/module_function_state.rb

@@ -54,6 +54,17 @@ module Rigor
     module ModuleFunctionState
       module_function
 
+      # The `[kind, owner]` of a deferred-range row for a `def` passed to a `module_function` spelling: `:singleton`
+      # for a singleton def, `:both` for an instance one, and `[nil, nil]` for a def on another object's singleton
+      # (#3155), which claims no owner or side.
+      def def_row_side(def_node, qualified_prefix, in_singleton_class, owner)
+        case ScopeIndexer.def_side(def_node, qualified_prefix, in_singleton_class)
+        when :singleton then [:singleton, owner]
+        when :instance then [:both, owner]
+        else [nil, nil]
+        end
+      end
+
       # A receiverless `module_function` call, bare or named.
       def call?(node)
         node.name == :module_function && node.receiver.nil?
@@ -360,8 +371,8 @@ module Rigor
           owner = qualified_prefix.empty? ? nil : qualified_prefix.join("::")
           node.arguments&.arguments&.each do |arg|
             if arg.is_a?(Prism::DefNode)
-              kind = ScopeIndexer.def_singleton?(arg, qualified_prefix, in_singleton_class) ? :singleton : :both
-              ranges << [arg.location.start_offset, arg.location.end_offset, arg.name, kind, owner]
+              ranges << [arg.location.start_offset, arg.location.end_offset, arg.name,
+                         *ModuleFunctionState.def_row_side(arg, qualified_prefix, in_singleton_class, owner)]
             elsif (name = symbol_argument_name(arg))
               ranges << [node.location.start_offset, node.location.end_offset, name, :singleton, owner]
             else

data/lib/rigor/inference/multi_target_binder.rb

@@ -302,7 +302,7 @@ module Rigor
         # and a per-slot `T | nil` fires `call.possible-nil-receiver` on the guarded read.
         def join_member_bindings(types, soften_slots)
           untyped = Type::Combinator.untyped
-          return [untyped, false] if types.any? { |type| type == untyped }
+          return [untyped, false] if types.any? { |type| Type::Combinator.untyped?(type) }
 
           firm = types.reject { |type| nil_literal?(type) }
           return [Type::Combinator.union(*types), false] if !soften_slots || firm.empty? || firm.size == types.size