rigortype 0.1.7 → 0.1.9

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

@@ -48,11 +48,21 @@ module Rigor
       module ConstantFolding # rubocop:disable Metrics/ModuleLength
         module_function
 
-        NUMERIC_BINARY = Set[:+, :-, :*, :/, :%, :<, :<=, :>, :>=, :==, :!=, :<=>].freeze
-        STRING_BINARY  = Set[:+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>].freeze
+        NUMERIC_BINARY = Set[
+          :+, :-, :*, :/, :%, :**, :&, :|, :^, :<<, :>>,
+          :<, :<=, :>, :>=, :==, :!=, :<=>,
+          :gcd, :lcm, :fdiv
+        ].freeze
+        STRING_BINARY  = Set[
+          :+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>,
+          :start_with?, :end_with?, :include?,
+          :delete_prefix, :delete_suffix,
+          :match?, :index, :rindex, :center, :ljust, :rjust
+        ].freeze
         SYMBOL_BINARY  = Set[:==, :!=, :<=>, :<, :<=, :>, :>=].freeze
-        BOOL_BINARY    = Set[:&, :|, :^, :==, :!=].freeze
+        BOOL_BINARY    = Set[:&, :|, :^, :==, :!=, :===].freeze
         NIL_BINARY     = Set[:==, :!=].freeze
+        RATIONAL_BINARY = Set[:div, :modulo, :%, :remainder, :fdiv].freeze
 
         # v0.0.3 C — pure unary catalogue. Each method must:
         # - take zero arguments,
@@ -74,20 +84,23 @@ module Rigor
           :odd?, :even?, :zero?, :positive?, :negative?,
           :succ, :pred, :next, :abs, :magnitude,
           :bit_length, :to_s, :to_i, :to_int, :to_f,
+          :floor, :ceil, :round, :truncate, :chr,
           :inspect, :hash, :-@, :+@, :~
         ].freeze
         FLOAT_UNARY = Set[
           :zero?, :positive?, :negative?,
           :nan?, :finite?, :infinite?,
           :abs, :magnitude, :floor, :ceil, :round, :truncate,
+          :next_float, :prev_float,
           :to_s, :to_i, :to_int, :to_f,
           :inspect, :hash, :-@, :+@
         ].freeze
         STRING_UNARY = Set[
           :upcase, :downcase, :capitalize, :swapcase,
           :reverse, :length, :size, :bytesize,
-          :empty?, :strip, :lstrip, :rstrip, :chomp,
+          :empty?, :strip, :lstrip, :rstrip, :chomp, :chop,
           :to_s, :to_str, :to_sym, :intern,
+          :to_i, :to_f, :ord, :chr, :hex, :oct, :succ, :next,
           :inspect, :hash
         ].freeze
         SYMBOL_UNARY = Set[
@@ -97,6 +110,11 @@ module Rigor
         ].freeze
         BOOL_UNARY = Set[:!, :to_s, :inspect, :hash, :&, :|, :^].freeze
         NIL_UNARY  = Set[:nil?, :!, :to_s, :to_a, :to_h, :inspect, :hash].freeze
+        RATIONAL_UNARY = Set[
+          :zero?, :integer?, :real, :abs2,
+          :conj, :conjugate, :nonzero?
+        ].freeze
+        COMPLEX_UNARY = Set[:zero?, :nonzero?].freeze
 
         STRING_FOLD_BYTE_LIMIT = 4096
 
@@ -283,6 +301,18 @@ module Rigor
           pathname_lift = try_fold_pathname_unary(receiver_values, method_name)
           return pathname_lift if pathname_lift
 
+          regexp_lift = try_fold_regexp_array_unary(receiver_values, method_name)
+          return regexp_lift if regexp_lift
+
+          set_lift = try_fold_set_array_unary(receiver_values, method_name)
+          return set_lift if set_lift
+
+          integer_lift = try_fold_integer_array_unary(receiver_values, method_name)
+          return integer_lift if integer_lift
+
+          numeric_lift = try_fold_numeric_array_unary(receiver_values, method_name)
+          return numeric_lift if numeric_lift
+
           # Type-level allow check on every receiver. If one member's
           # type does not have the method in its allow list (e.g.
           # `Union[String, nil].nil?` — `:nil?` is not in
@@ -309,7 +339,7 @@ module Rigor
         # Only fires on a single-receiver Range with finite integer
         # endpoints; mixed unions fall through so the existing
         # union-of-Constants path keeps the rest of the arms.
-        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length].freeze
+        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length, :entries, :minmax].freeze
         RANGE_TO_A_LIMIT = 16
         private_constant :RANGE_FOLD_METHODS, :RANGE_TO_A_LIMIT
 
@@ -326,10 +356,11 @@ module Rigor
 
         def range_constant_unary(range, method_name)
           case method_name
-          when :to_a then range_to_a_tuple(range)
+          when :to_a, :entries then range_to_a_tuple(range)
           when :first, :min then range_endpoint_constant(range, :first)
           when :last, :max then range_endpoint_constant(range, :last)
           when :count, :size, :length then Type::Combinator.constant_of(range.to_a.size)
+          when :minmax then range_minmax_tuple(range)
           end
         end
 
@@ -348,6 +379,21 @@ module Rigor
           Type::Combinator.constant_of(edge == :first ? values.first : values.last)
         end
 
+        def range_minmax_tuple(range)
+          values = range.to_a
+          if values.empty?
+            return Type::Combinator.tuple_of(
+              Type::Combinator.constant_of(nil),
+              Type::Combinator.constant_of(nil)
+            )
+          end
+
+          Type::Combinator.tuple_of(
+            Type::Combinator.constant_of(values.first),
+            Type::Combinator.constant_of(values.last)
+          )
+        end
+
         def try_fold_binary_set(receiver_values, method_name, arg_values)
           string_lift = try_fold_string_array_binary(receiver_values, method_name, arg_values)
           return string_lift if string_lift
@@ -377,6 +423,30 @@ module Rigor
                          :STRING_ARRAY_BINARY_METHODS,
                          :STRING_ARRAY_LIFT_LIMIT
 
+        # `Constant<Regexp>#names` returns an Array of capture-group name
+        # strings. Lifted to a Tuple so downstream narrowing can project
+        # per-element types. The catalog classifies the C body as `:leaf`
+        # so it is safe to evaluate at fold time; no `$~` side effect.
+        REGEXP_ARRAY_UNARY_METHODS = Set[:names].freeze
+        private_constant :REGEXP_ARRAY_UNARY_METHODS
+
+        # `Constant<Set>#to_a` returns an Array of the set's elements.
+        # Ruby 3.2+ Set is C-implemented with a Hash as its backing store,
+        # so element ordering is deterministic (insertion order).
+        # The catalog marks `to_a` as `:dispatch` (it calls through to the
+        # internal hash), so this dedicated handler bypasses the catalog gate.
+        SET_ARRAY_UNARY_METHODS = Set[:to_a, :entries].freeze
+        private_constant :SET_ARRAY_UNARY_METHODS
+
+        # `Constant<Integer>#digits` returns the base-10 (or base-n with
+        # an argument — only the no-arg form is folded here) place
+        # values as a little-endian Array of Integers. Lifted to a
+        # Tuple so downstream rules see the precise per-position type.
+        # `digits` raises `Math::DomainError` on a negative receiver,
+        # so the negative case bails to the RBS tier.
+        INTEGER_ARRAY_UNARY_METHODS = Set[:digits].freeze
+        private_constant :INTEGER_ARRAY_UNARY_METHODS
+
         # v0.0.7 — `Constant<Pathname>` delegates to a curated set
         # of pure path-manipulation methods. Pathname is immutable
         # in Ruby (per its docstring) and the catalog classifies
@@ -446,6 +516,83 @@ module Rigor
           nil
         end
 
+        # `Constant<Regexp>#names` — lift the Array[String] of named-capture
+        # group names to a Tuple[Constant[String]…]. Safe to evaluate at fold
+        # time: the C body reads only the regexp's internal names table,
+        # writes no global state, and always returns an Array of frozen Strings.
+        def try_fold_regexp_array_unary(receiver_values, method_name)
+          return nil unless REGEXP_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Regexp)
+
+          lift_array_result(receiver.public_send(method_name))
+        rescue StandardError
+          nil
+        end
+
+        # `Constant<Set>#to_a` / `#entries` — lift the Array of set elements
+        # to a Tuple[Constant[…]…] when every element is a foldable scalar.
+        # Ruby 3.2+ Set is C-implemented; element order is deterministic
+        # (insertion order), so the result is stable across invocations.
+        def try_fold_set_array_unary(receiver_values, method_name)
+          return nil unless SET_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(::Set)
+
+          lift_array_result(receiver.to_a)
+        rescue StandardError
+          nil
+        end
+
+        # `Constant<Integer>#digits` — lift the Array of base-10 place
+        # values to a Tuple[Constant[Integer]…]. Safe to evaluate at
+        # fold time: the C body is pure arithmetic. Negative receivers
+        # raise `Math::DomainError`; the fold declines so the RBS tier
+        # answers with `Array[Integer]`.
+        def try_fold_integer_array_unary(receiver_values, method_name)
+          return nil unless INTEGER_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Integer)
+          return nil if receiver.negative?
+
+          lift_array_result(receiver.digits)
+        rescue StandardError
+          nil
+        end
+
+        # `Constant<Complex>#rect` / `#rectangular` — lifts `[real, imaginary]`
+        # to `Tuple[Constant[re], Constant[im]]`. Both components are always
+        # numeric (Integer or Float for literal complexes), so they satisfy
+        # `foldable_constant_value?`.
+        #
+        # `Constant<Complex>#polar` — lifts `[abs, arg]` to
+        # `Tuple[Constant[Float], Constant[Float]]`. Evaluated at fold time
+        # via `Complex#polar` (which calls `Math.hypot` and `Math.atan2`).
+        # Deterministic: reads only the receiver's real and imaginary parts.
+        #
+        # Rational receivers also support `rect` / `rectangular` / `polar`:
+        # `Rational(r,1).rect` → `[r, 0]`, `Rational(r,1).polar` → `[abs, arg]`.
+        NUMERIC_ARRAY_UNARY_METHODS = Set[:rect, :rectangular, :polar].freeze
+        private_constant :NUMERIC_ARRAY_UNARY_METHODS
+
+        def try_fold_numeric_array_unary(receiver_values, method_name)
+          return nil unless NUMERIC_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Complex) || receiver.is_a?(Rational)
+
+          lift_array_result(receiver.public_send(method_name))
+        rescue StandardError
+          nil
+        end
+
         # `Constant<String>#split(arg)` / `#scan(arg)` — lift the
         # Array result to a Tuple when both sides are statically
         # known and the cardinality fits.
@@ -1101,6 +1248,8 @@ module Rigor
           when Symbol         then SYMBOL_UNARY
           when true, false    then BOOL_UNARY
           when nil            then NIL_UNARY
+          when Rational       then RATIONAL_UNARY
+          when Complex        then COMPLEX_UNARY
           else                     Set.new
           end
         end
@@ -1126,11 +1275,15 @@ module Rigor
         # have their own shape carriers; this method picks
         # the conservative envelope of "values that already
         # round-trip through `Type::Combinator.constant_of`".
+        FOLDABLE_CONSTANT_CLASSES = [
+          Integer, Float, Rational, Complex, String, Symbol,
+          Regexp, Pathname, ::Set, Date, Time,
+          TrueClass, FalseClass, NilClass
+        ].freeze
+        private_constant :FOLDABLE_CONSTANT_CLASSES
+
         def foldable_constant_value?(value)
-          case value
-          when Integer, Float, Rational, Complex, String, Symbol, Regexp, Pathname, true, false, nil then true
-          else false
-          end
+          FOLDABLE_CONSTANT_CLASSES.any? { |klass| value.is_a?(klass) }
         end
 
         def safe?(receiver_value, method_name, arg_value)
@@ -1150,6 +1303,7 @@ module Rigor
           when Symbol         then SYMBOL_BINARY
           when true, false    then BOOL_BINARY
           when nil            then NIL_BINARY
+          when Rational       then RATIONAL_BINARY
           else                     Set.new
           end
         end
@@ -1169,10 +1323,19 @@ module Rigor
           case method_name
           when :+ then string_concat_blow_up?(receiver_value, arg_value)
           when :* then string_repeat_blow_up?(receiver_value, arg_value)
+          when :center, :ljust, :rjust then string_pad_blow_up?(arg_value)
           else false
           end
         end
 
+        # `"x".center(width)` / `#ljust` / `#rjust` produce a string
+        # of `max(width, len)` characters. A literal `width` far
+        # larger than the receiver would materialise a huge Constant;
+        # cap it at the same byte limit the concat / repeat paths use.
+        def string_pad_blow_up?(arg_value)
+          arg_value.is_a?(Integer) && arg_value > STRING_FOLD_BYTE_LIMIT
+        end
+
         def string_concat_blow_up?(receiver_value, arg_value)
           arg_value.is_a?(String) &&
             receiver_value.bytesize + arg_value.bytesize > STRING_FOLD_BYTE_LIMIT

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

@@ -57,11 +57,63 @@ module Rigor
           return nil if receiver.nil?
           return try_array(args) if method_name == :Array
           return try_numeric_constructor(method_name, args) if NUMERIC_CONSTRUCTORS.key?(method_name)
-          return try_integer_from_refinement(args) if method_name == :Integer
+          return try_integer(args) if method_name == :Integer
+          return try_float(args) if method_name == :Float
 
           nil
         end
 
+        # `Kernel#Integer(arg)` / `Integer(arg, base)`. Two folding
+        # paths, tried in order:
+        #
+        # 1. A `Refined[String, predicate]` argument whose predicate
+        #    is a digit-only carrier narrows to `non-negative-int`
+        #    (see {try_integer_from_refinement}).
+        # 2. A `Constant` String or Numeric argument — optionally
+        #    with a `Constant[Integer]` base — runs the actual
+        #    `Integer()` conversion and lifts the result to
+        #    `Constant[Integer]`.
+        def try_integer(args)
+          refined = try_integer_from_refinement(args)
+          return refined if refined
+
+          try_integer_constant(args)
+        end
+
+        # Constant-folding path for `Integer()`. A non-parseable
+        # string raises `ArgumentError` (or `TypeError` for a base
+        # against a non-string) at fold time; the handler declines
+        # so the RBS tier answers with the widened `Integer`.
+        def try_integer_constant(args)
+          return nil unless [1, 2].include?(args.size)
+          return nil unless args.all?(Type::Constant)
+
+          values = args.map(&:value)
+          return nil unless values[0].is_a?(String) || values[0].is_a?(Numeric)
+          return nil if values.size == 2 && !values[1].is_a?(Integer)
+
+          Type::Combinator.constant_of(Integer(*values))
+        rescue ArgumentError, TypeError
+          nil
+        end
+
+        # `Kernel#Float(arg)` — folds a `Constant` String or Numeric
+        # argument to `Constant[Float]`. A non-parseable string
+        # raises `ArgumentError` at fold time; the handler declines.
+        def try_float(args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant)
+
+          value = arg.value
+          return nil unless value.is_a?(String) || value.is_a?(Numeric)
+
+          Type::Combinator.constant_of(Float(value))
+        rescue ArgumentError, TypeError
+          nil
+        end
+
         # `Kernel#Integer(s)` over a `Refined[String, predicate]`
         # whose predicate is in {INTEGER_REFINEMENT_PREDICATES}.
         # Mirrors the `String#to_i` projection in `ShapeDispatch`

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Folds `Math` module-function calls on statically known numeric
+      # constants.
+      #
+      # `Math` is a pure, side-effect-free module whose functions are
+      # deterministic over their inputs — the same number always
+      # produces the same result. When every relevant argument is a
+      # `Constant` carrying a `Numeric` value, the analyzer evaluates
+      # the call at inference time and returns the concrete result.
+      #
+      # === Supported methods
+      #
+      # * Single-argument transcendental functions (`sqrt`, `cbrt`,
+      #   `exp`, `log2`, `log10`, `log1p`, `expm1`, `sin`, `cos`,
+      #   `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`,
+      #   `asinh`, `acosh`, `atanh`, `erf`, `erfc`, `gamma`) — return
+      #   `Constant[Float]`.
+      #
+      # * Two-argument functions (`atan2`, `hypot`, `ldexp`) — return
+      #   `Constant[Float]`.
+      #
+      # * `log(x)` / `log(x, base)` — variadic; folds the 1- and
+      #   2-argument forms to `Constant[Float]`.
+      #
+      # * `frexp(x)` / `lgamma(x)` — return a two-element array, lifted
+      #   to `Tuple[Constant[Float], Constant[Integer]]`.
+      #
+      # === Non-constant / unsupported cases
+      #
+      # Any call where the receiver is not `Singleton[Math]`, an
+      # argument is not a numeric `Constant`, the method is not in the
+      # supported set, or the Ruby call raises `Math::DomainError` /
+      # `RangeError` (domain-error inputs like `Math.sqrt(-1)`) returns
+      # `nil`, deferring to the next dispatcher tier.
+      #
+      # An infinite or NaN result (`Math.log(0.0)` → `-Infinity`) is
+      # still folded — `Constant[Float]` carries those values, matching
+      # `ConstantFolding`'s treatment of `Float / 0`.
+      module MathFolding
+        MATH_UNARY = Set[
+          :sqrt, :cbrt, :exp, :log2, :log10, :log1p, :expm1,
+          :sin, :cos, :tan, :asin, :acos, :atan,
+          :sinh, :cosh, :tanh, :asinh, :acosh, :atanh,
+          :erf, :erfc, :gamma
+        ].freeze
+        MATH_BINARY = Set[:atan2, :hypot, :ldexp].freeze
+        MATH_TUPLE_UNARY = Set[:frexp, :lgamma].freeze
+
+        private_constant :MATH_UNARY, :MATH_BINARY, :MATH_TUPLE_UNARY
+
+        module_function
+
+        # @return [Rigor::Type, nil] folded result, or nil to defer.
+        def try_dispatch(receiver:, method_name:, args:)
+          return nil unless dispatch_target?(receiver)
+
+          # `log` is variadic (1 or 2 args), so it cannot live in the
+          # fixed-arity sets above.
+          return fold_log(args) if method_name == :log
+          return fold_unary(method_name, args) if MATH_UNARY.include?(method_name)
+          return fold_binary(method_name, args) if MATH_BINARY.include?(method_name)
+          return fold_tuple_unary(method_name, args) if MATH_TUPLE_UNARY.include?(method_name)
+
+          nil
+        end
+
+        def dispatch_target?(receiver)
+          receiver.is_a?(Type::Singleton) && receiver.class_name == "Math"
+        end
+
+        # Unwraps a numeric `Constant` argument to its Ruby value.
+        # Returns nil for any non-`Constant` or non-`Numeric` carrier.
+        def numeric_constant(arg)
+          return nil unless arg.is_a?(Type::Constant)
+
+          value = arg.value
+          value.is_a?(Numeric) ? value : nil
+        end
+
+        def fold_unary(method_name, args)
+          return nil unless args.size == 1
+
+          x = numeric_constant(args.first)
+          return nil if x.nil?
+
+          fold_float_result(Math.public_send(method_name, x))
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        def fold_binary(method_name, args)
+          return nil unless args.size == 2
+
+          a = numeric_constant(args[0])
+          b = numeric_constant(args[1])
+          return nil if a.nil? || b.nil?
+
+          fold_float_result(Math.public_send(method_name, a, b))
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        # `Math.log(x)` and `Math.log(x, base)` — the only variadic
+        # `Math` function.
+        def fold_log(args)
+          return nil unless [1, 2].include?(args.size)
+
+          values = args.map { |a| numeric_constant(a) }
+          return nil if values.any?(&:nil?)
+
+          fold_float_result(Math.log(*values))
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        # `Math.frexp` / `Math.lgamma` return a two-element array;
+        # lift it to `Tuple[Constant[Float], Constant[Integer]]`.
+        def fold_tuple_unary(method_name, args)
+          return nil unless args.size == 1
+
+          x = numeric_constant(args.first)
+          return nil if x.nil?
+
+          result = Math.public_send(method_name, x)
+          return nil unless result.is_a?(Array) && result.size == 2
+
+          Type::Combinator.tuple_of(
+            Type::Combinator.constant_of(result[0]),
+            Type::Combinator.constant_of(result[1])
+          )
+        rescue Math::DomainError, RangeError
+          nil
+        end
+
+        def fold_float_result(result)
+          return nil unless result.is_a?(Float)
+
+          Type::Combinator.constant_of(result)
+        end
+      end
+    end
+  end
+end

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

@@ -122,13 +122,30 @@ module Rigor
           return match if match
           return overloads.find { |mt| overload_has_block?(mt) } if block_required
 
-          overloads.first
+          # No block at the call site: prefer an overload that does
+          # not REQUIRE a block over `overloads.first`. Methods like
+          # `Array#filter` / `Enumerable#map` declare the block-
+          # bearing overload first (`() { ... } -> Array[Elem]`) and
+          # the bare-call overload second (`() -> Enumerator[...]`).
+          # Without this, a no-block `[1, 2].filter` would adopt the
+          # block overload's `Array[Elem]` return when the call
+          # actually yields an `Enumerator`.
+          overloads.find { |mt| !overload_requires_block?(mt) } || overloads.first
         end
 
         def overload_has_block?(method_type)
           method_type.respond_to?(:block) && method_type.block
         end
 
+        # True when the overload declares a block that the caller
+        # MUST supply (`{ ... }` in RBS). An optional block
+        # (`?{ ... }`) does NOT count — that overload is a valid
+        # match for a block-less call.
+        def overload_requires_block?(method_type)
+          block = overload_has_block?(method_type)
+          !!block && block.required
+        end
+
         class << self
           private
 
@@ -163,6 +180,7 @@ module Rigor
 
             overloads.find do |method_type|
               next false if block_required && !OverloadSelector.overload_has_block?(method_type)
+              next false if !block_required && OverloadSelector.overload_requires_block?(method_type)
               next false if strict && !strictly_typed_params?(method_type, arg_types.size)
 
               matches?(
@@ -199,6 +217,7 @@ module Rigor
           def find_matching_overload_via_aliases(overloads, arg_types:, block_required:)
             overloads.find do |method_type|
               next false if block_required && !OverloadSelector.overload_has_block?(method_type)
+              next false if !block_required && OverloadSelector.overload_requires_block?(method_type)
 
               fun = method_type.type
               next false unless arity_compatible?(fun, arg_types.size)

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

@@ -85,10 +85,17 @@ module Rigor
         #   `Bundler::URI::Generic` per `Kernel#dup: () -> self`
         #   rather than `Object`. Defaults to nil (compute self
         #   from the resolved class_name as before).
+        # @param public_only [Boolean] when true, a method whose RBS
+        #   accessibility is `:private` does not resolve (the call
+        #   yields `nil`, i.e. "no rule"). Set by the explicit-
+        #   non-`self`-receiver user-class fallback so a call like
+        #   `Favourite.select(...)` does not adopt the private
+        #   `Kernel#select` signature.
         # @return [Rigor::Type, nil] inferred return type, or `nil`
         #   when no rule resolves (no class name, no method, dispatch
         #   on a Top/Dynamic[Top] receiver, etc.).
-        def try_dispatch(receiver:, method_name:, args:, environment:, block_type: nil, self_type_override: nil)
+        def try_dispatch(receiver:, method_name:, args:, environment:, block_type: nil, self_type_override: nil,
+                         public_only: false)
           return nil if environment.nil?
           return nil unless environment.rbs_loader
 
@@ -98,7 +105,8 @@ module Rigor
             args: args,
             environment: environment,
             block_type: block_type,
-            self_type_override: self_type_override
+            self_type_override: self_type_override,
+            public_only: public_only
           )
         end
 
@@ -140,32 +148,39 @@ module Rigor
         class << self
           private
 
-          def dispatch_for(receiver:, method_name:, args:, environment:, block_type:, self_type_override: nil)
+          def dispatch_for(receiver:, method_name:, args:, environment:, block_type:, self_type_override: nil,
+                           public_only: false)
             args ||= []
             case receiver
             when Type::Union
-              dispatch_union(receiver, method_name, args, environment, block_type, self_type_override)
+              dispatch_union(receiver, method_name, args, environment, block_type, self_type_override,
+                             public_only: public_only)
             else
-              dispatch_one(receiver, method_name, args, environment, block_type, self_type_override)
+              dispatch_one(receiver, method_name, args, environment, block_type, self_type_override,
+                           public_only: public_only)
             end
           end
 
-          def dispatch_union(receiver, method_name, args, environment, block_type, self_type_override = nil)
+          def dispatch_union(receiver, method_name, args, environment, block_type, self_type_override = nil,
+                             public_only: false)
             results = receiver.members.map do |member|
-              dispatch_one(member, method_name, args, environment, block_type, self_type_override)
+              dispatch_one(member, method_name, args, environment, block_type, self_type_override,
+                           public_only: public_only)
             end
             return nil if results.any?(&:nil?)
 
             Type::Combinator.union(*results)
           end
 
-          def dispatch_one(receiver, method_name, args, environment, block_type, self_type_override = nil)
+          def dispatch_one(receiver, method_name, args, environment, block_type, self_type_override = nil,
+                           public_only: false)
             descriptor = receiver_descriptor(receiver)
             return nil unless descriptor
 
             class_name, kind, receiver_args = descriptor
             method_definition = lookup_method(environment, class_name, kind, method_name)
             return nil unless method_definition
+            return nil if public_only && method_private?(method_definition)
 
             type_vars = build_type_vars(environment, class_name, receiver_args)
             translate_return_type(
@@ -242,6 +257,16 @@ module Rigor
             ]
           end
 
+          # True when the RBS method definition is `private`. A call
+          # with an explicit, non-`self` receiver cannot reach a
+          # private method (Ruby raises `NoMethodError`), so the
+          # explicit-receiver user-class fallback uses this to reject
+          # private signatures rather than return a wrong type.
+          def method_private?(method_definition)
+            method_definition.respond_to?(:accessibility) &&
+              method_definition.accessibility == :private
+          end
+
           def lookup_method(environment, class_name, kind, method_name)
             case kind
             when :instance