rigortype 0.3.8 → 0.3.9

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

@@ -44,11 +44,23 @@ module Rigor
         MATH_BINARY = Set[:atan2, :hypot, :ldexp].freeze
         MATH_TUPLE_UNARY = Set[:frexp, :lgamma].freeze
 
-        private_constant :MATH_UNARY, :MATH_BINARY, :MATH_TUPLE_UNARY
+        # ADR-109 — the monotone non-decreasing functions, each with the inclusive lower edge of its
+        # domain (`nil` for every real). Over a bounded argument the image is the closed range between the
+        # images of the bounds: `Math.sqrt(Integer[0..])` is `Float[0.0..]`, `Math.exp(Float[..0.0])` is
+        # `Float[0.0..1.0]`. A bound below the domain edge raises at run time for the value that reaches
+        # it, so the fold declines. Not listed: the non-monotone functions (`sin`, `cos`, `tan`, `gamma`,
+        # `erfc` decreases, `acos` decreases) and the ones whose image needs a sign split.
+        MATH_MONOTONE_DOMAIN = {
+          sqrt: 0.0, cbrt: nil, exp: nil, expm1: nil,
+          log: 0.0, log2: 0.0, log10: 0.0, log1p: -1.0,
+          atan: nil, sinh: nil, tanh: nil, asinh: nil, erf: nil
+        }.freeze
+
+        private_constant :MATH_UNARY, :MATH_BINARY, :MATH_TUPLE_UNARY, :MATH_MONOTONE_DOMAIN
 
         module_function
 
-        # @return [Rigor::Type, nil] folded result, or nil to defer.
+        # @return folded result, or nil to defer.
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name
@@ -77,13 +89,38 @@ module Rigor
           return nil unless args.size == 1
 
           x = numeric_constant(args.first)
-          return nil if x.nil?
+          return fold_monotone_range(method_name, args.first) if x.nil?
 
           fold_float_result(Math.public_send(method_name, x))
         rescue Math::DomainError, RangeError
           nil
         end
 
+        # The bounded-argument arm of {fold_unary} / {fold_log}: an `IntegerRange` or `FloatRange`
+        # argument to a monotone function folds to the range between the images of its bounds.
+        def fold_monotone_range(method_name, arg)
+          return nil unless MATH_MONOTONE_DOMAIN.key?(method_name)
+
+          lower, upper = range_bounds(arg)
+          return nil if lower.nil?
+
+          edge = MATH_MONOTONE_DOMAIN[method_name]
+          return nil if edge && lower < edge
+
+          Type::Combinator.float_range(Math.public_send(method_name, lower), Math.public_send(method_name, upper))
+        rescue Math::DomainError, RangeError, ArgumentError
+          nil
+        end
+
+        # `[lower, upper]` as doubles for a bounded numeric carrier, `nil` for anything else. An
+        # exclusive Float end reads as its canonical closed bound, one double below.
+        def range_bounds(arg)
+          case arg
+          when Type::FloatRange then [arg.min, arg.canonical_max]
+          when Type::IntegerRange then [arg.lower.to_f, arg.upper.to_f]
+          end
+        end
+
         def fold_binary(method_name, args)
           return nil unless args.size == 2
 
@@ -101,6 +138,7 @@ module Rigor
           return nil unless [1, 2].include?(args.size)
 
           values = args.map { |a| numeric_constant(a) }
+          return fold_monotone_range(:log, args.first) if args.size == 1 && values.first.nil?
           return nil if values.any?(&:nil?)
 
           fold_float_result(Math.log(*values))

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

@@ -29,11 +29,8 @@ module Rigor
         # `.method("name")` with a precisely-known Symbol / String argument. Declines on every other shape
         # so the RBS tier still answers `Method` for non-folding cases.
         #
-        # @param receiver [Rigor::Type] caller's receiver
-        # @param method_name [Symbol] the method being dispatched on `receiver` — only `:method` triggers
-        #   the fold.
-        # @param args [Array<Rigor::Type>] caller's argument types in order. Only the single-argument case
-        #   matches; other arities decline.
+        # Reads `context.receiver`, `context.method_name` (only `:method` triggers the fold) and `context.args`
+        # (only the single-argument case matches; other arities decline).
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name

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

@@ -64,21 +64,20 @@ module Rigor
         }.freeze
         private_constant :ALIAS_STRICT_NOMINALS
 
-        # @param method_definition [RBS::Definition::Method]
-        # @param arg_types [Array<Rigor::Type>] caller-provided types in positional order. Empty when
+        # @param arg_types — caller-provided types in positional order. Empty when
         #   there are no arguments.
-        # @param self_type [Rigor::Type] substitute for `Bases::Self`.
-        # @param instance_type [Rigor::Type] substitute for `Bases::Instance`.
-        # @param type_vars [Hash{Symbol => Rigor::Type}] substitution map for class-level type variables
+        # @param self_type — substitute for `Bases::Self`.
+        # @param instance_type — substitute for `Bases::Instance`.
+        # @param type_vars — substitution map for class-level type variables
         #   (Slice 4 phase 2d). The selector threads it through to {RbsTypeTranslator} so parameter types
         #   like `::Array[Elem]` substitute Elem before the accepts check, instead of degrading the param
         #   to `Array[Dynamic[Top]]`.
-        # @param block_required [Boolean] when `true`, only overloads that declare a block clause are
+        # @param block_required — when `true`, only overloads that declare a block clause are
         #   considered (Slice 6 phase C sub-phase 1). The fallback also prefers a block-bearing overload
         #   over `method_types.first`. When `false` (the Slice 4 phase 2c default) the selector behaves
         #   exactly as before: `find` over arity-compatible overloads, falling back to the first
         #   declaration.
-        # @return [RBS::MethodType, nil] the chosen overload, or nil when the definition has no method
+        # @return the chosen overload, or nil when the definition has no method
         #   types at all.
         def select(method_definition, **) = select_candidates(method_definition, **).first
 
@@ -91,7 +90,7 @@ module Rigor
         # alias-resolved, typed-gradual, arity fallback) still yields exactly one candidate, so `select`
         # keeps its historical single answer.
         #
-        # @return [Array<RBS::MethodType>] matching overloads; empty when the definition declares none.
+        # @return matching overloads; empty when the definition declares none.
         def select_candidates(method_definition, arg_types:, self_type:, instance_type:, type_vars: {},
                               block_required: false, environment: nil)
           overloads = method_definition.method_types
@@ -108,17 +107,14 @@ module Rigor
           # an arbitrary sibling-class arm that only wins by overload-list position.
           overloads = ReceiverAffinity.reorder(overloads, self_type: self_type, environment: environment)
 
-          alias_expander = environment&.rbs_loader
-          passes = lambda do |require_block|
-            run_selection_passes(
-              overloads,
-              { arg_types: arg_types, self_type: self_type, instance_type: instance_type,
-                type_vars: type_vars, block_required: require_block, param_overrides: param_overrides,
-                alias_expander: alias_expander }
-            )
-          end
+          # One keyword bundle for the pass pipeline (see `run_selection_passes`); a block retry rebuilds it
+          # with the block flag cleared. Built once and passed positionally -- the previous lambda plus a
+          # `**shared` splat per pass allocated three objects per selection (#775).
+          shared = { arg_types: arg_types, self_type: self_type, instance_type: instance_type,
+                     type_vars: type_vars, block_required: block_required, param_overrides: param_overrides,
+                     alias_expander: environment&.rbs_loader }
 
-          matches = passes.call(block_required)
+          matches = run_selection_passes(overloads, shared)
           return matches unless matches.empty?
 
           # A block at the call site that no block-declaring overload matched: Ruby ignores a block handed
@@ -127,7 +123,7 @@ module Rigor
           # `define_command(:x) do … end` against `def define_command: (Symbol) -> Symbol`) degraded to
           # `Dynamic[Top]` — and on a self-send suppressed the whole method's return type.
           if block_required
-            matches = passes.call(false)
+            matches = run_selection_passes(overloads, shared.merge(block_required: false))
             return matches unless matches.empty?
           end
 
@@ -165,7 +161,7 @@ module Rigor
           # `shared` is the caller-assembled keyword bundle for `find_matching_overload` — hash-shaped
           # because the pass pipeline forwards it twice and RuboCop's parameter-list budget is real.
           def run_selection_passes(overloads, shared)
-            strict = find_matching_overload(overloads, **shared, strict: true)
+            strict = find_matching_overload(overloads, shared, strict: true)
             return strict unless strict.empty?
 
             alias_hit = find_matching_overload_via_aliases(
@@ -177,33 +173,37 @@ module Rigor
             # match keeps its historical single-winner contract. With a `Dynamic[Top]` argument in play the
             # matches are indistinguishable by types — position alone would pick — so ALL of them come back
             # and the dispatch layer unions their returns (#521).
-            matches = find_matching_overload(overloads, **shared, strict: false)
+            matches = find_matching_overload(overloads, shared, strict: false)
             return matches.first(1) unless shared[:arg_types].any? { |t| untyped_arg?(t) }
 
             matches
           end
 
-          # rubocop:disable-next Metrics/ParameterLists
-          def find_matching_overload(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:,
-                                     param_overrides:, strict:, alias_expander: nil)
-            return [] if strict && arg_types.any? { |t| untyped_arg?(t) }
+          # The shared "no overload matched" answer; every consumer only reads the list.
+          NO_MATCH = [].freeze
+          private_constant :NO_MATCH
 
-            predicate = lambda do |method_type|
-              next false unless engages_block_shape?(method_type, block_required)
-              next false if strict && !strictly_typed_params?(method_type, arg_types.size)
+          # `shared` is the keyword bundle `select_candidates` assembled (arg_types, self_type, instance_type,
+          # type_vars, block_required, param_overrides, alias_expander).
+          def find_matching_overload(overloads, shared, strict:)
+            arg_types = shared[:arg_types]
+            return NO_MATCH if strict && arg_types.any? { |t| untyped_arg?(t) }
 
-              matches?(
-                method_type, arg_types,
-                self_type: self_type, instance_type: instance_type,
-                type_vars: type_vars, param_overrides: param_overrides,
-                alias_expander: alias_expander
-              )
-            end
+            block_required = shared[:block_required]
             # Strict keeps its historical first-match short-circuit (a dispatch hot path); the gradual
             # pass needs the full candidate list for the #521 union.
-            return [overloads.find(&predicate)].compact if strict
+            if strict
+              found = overloads.find do |method_type|
+                engages_block_shape?(method_type, block_required) &&
+                  strictly_typed_params?(method_type, arg_types.size) &&
+                  matches?(method_type, shared)
+              end
+              return found ? [found] : NO_MATCH
+            end
 
-            overloads.select(&predicate)
+            overloads.select do |method_type|
+              engages_block_shape?(method_type, block_required) && matches?(method_type, shared)
+            end
           end
 
           # Whether the overload's block clause is compatible with the call site's block shape: a
@@ -243,10 +243,19 @@ module Rigor
               params = positional_params_for(fun, arg_types.size)
               next false unless params.size == arg_types.size
 
-              params.zip(arg_types).all? { |param, arg| alias_param_accepts?(param.type, arg) }
+              each_param_accepts?(params, arg_types) { |param, arg| alias_param_accepts?(param.type, arg) }
             end
           end
 
+          # `params.zip(arg_types).all? { |param, arg| ... }` without the pair arrays: a formal beyond the
+          # actuals meets `nil`, exactly as `zip` pads. Selection zips once per overload per pass, so the
+          # pairs were a top allocation site of dispatch (#775). The counter is a captured local, so the
+          # walk allocates nothing (a Range or an Enumerator would be one object per overload per pass).
+          def each_param_accepts?(params, arg_types)
+            index = -1
+            params.all? { |param| yield(param, arg_types[index += 1]) }
+          end
+
           # Checks the param's RBS type against an arg using alias-strict-arm matching. Optional / Union
           # wrappers are flattened; alias resolution is one level deep (the canonical core aliases all have
           # non-alias strict arms).
@@ -317,23 +326,24 @@ module Rigor
             end
           end
 
-          def matches?(method_type, arg_types, self_type:, instance_type:, type_vars:, param_overrides:,
-                       alias_expander: nil)
+          # `shared` is the keyword bundle `select_candidates` assembled (see `find_matching_overload`).
+          def matches?(method_type, shared)
             return false if method_type.respond_to?(:type_params) && rejects_keyword_required?(method_type)
 
+            arg_types = shared[:arg_types]
             fun = method_type.type
             return false unless arity_compatible?(fun, arg_types.size)
 
             params = positional_params_for(fun, arg_types.size)
-            params.zip(arg_types).all? do |param, arg|
+            each_param_accepts?(params, arg_types) do |param, arg|
               accepts_param?(
                 param,
                 arg,
-                self_type: self_type,
-                instance_type: instance_type,
-                type_vars: type_vars,
-                param_overrides: param_overrides,
-                alias_expander: alias_expander
+                self_type: shared[:self_type],
+                instance_type: shared[:instance_type],
+                type_vars: shared[:type_vars],
+                param_overrides: shared[:param_overrides],
+                alias_expander: shared[:alias_expander]
               )
             end
           end
@@ -376,8 +386,12 @@ module Rigor
             rest = fun.rest_positionals
             trailing = fun.trailing_positionals
 
+            optional_needed = [actual_count - required.size - trailing.size, 0].max
+            # Nothing to append: the declaration's own list is the answer, read-only (the common
+            # required-positionals-only overload -- no copy, #775).
+            return required if optional_needed.zero? && trailing.empty? && (rest.nil? || actual_count <= required.size)
+
             head = required.dup
-            optional_needed = [actual_count - head.size - trailing.size, 0].max
             head.concat(optional.first(optional_needed))
 
             absorbed_by_rest = actual_count - head.size - trailing.size

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "singleton_folding"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # ADR-109 — the interval a random draw over a literal range lands in. `Random.rand` and
+      # `Kernel#rand` advance a generator, so no call folds to a constant ({Builtins::RANDOM_CATALOG}
+      # says why); but a draw over `a..b` returns a value the range covers, and that is a bounded
+      # carrier of the range's own class, keeping its written end:
+      #
+      #   rand(1..6)              -> Integer[1..6]
+      #   rand(1...6)             -> Integer[1..5]
+      #   rand(0.0...1.0)         -> Float[0.0...1.0]
+      #   Random.rand(1.0..2.0)   -> Float[1.0..2.0]
+      #
+      # An empty range (`rand(5..1)` returns nil, `Random.rand(5..1)` raises), an unbounded one
+      # (`Errno::EDOM`) and a non-literal argument decline to the RBS envelope. The other argument
+      # shapes (`rand`, `rand(n)`, `rand(1.5)`) are deliberately NOT folded: the corpus uses them as its
+      # "unknown Integer / Float" oracle, and their intervals belong to a change that replaces that
+      # oracle first. The `Kernel` spelling is folded by {KernelDispatch#try_rand} behind ADR-91's
+      # ownership gate; this module owns `Singleton[Random]` and the shared interval reading.
+      module RandomFolding
+        module_function
+
+        def try_dispatch(context)
+          return nil unless SingletonFolding.receiver?(context.receiver, "Random")
+          return nil unless context.method_name == :rand
+
+          interval_for_args(context.args)
+        end
+
+        # The bounded carrier a one-argument draw over a literal range lands in, or `nil` for any other
+        # argument shape.
+        def interval_for_args(args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Range)
+
+          range_interval(arg.value)
+        end
+
+        def range_interval(range)
+          lower = range.begin
+          upper = range.end
+          return nil unless real_endpoint?(lower) && real_endpoint?(upper)
+
+          if lower.is_a?(Integer) && upper.is_a?(Integer)
+            integer_range_interval(lower, upper, range.exclude_end?)
+          else
+            float_range_interval(lower.to_f, upper.to_f, range.exclude_end?)
+          end
+        end
+
+        # A finite Integer or Float; a missing end is `Errno::EDOM` at run time.
+        def real_endpoint?(value)
+          case value
+          when Integer then true
+          when Float then value.finite?
+          else false
+          end
+        end
+
+        def integer_range_interval(lower, upper, exclusive)
+          upper -= 1 if exclusive
+          return nil if lower > upper
+
+          Type::Combinator.integer_range(lower, upper)
+        end
+
+        def float_range_interval(lower, upper, exclusive)
+          return nil if lower > (exclusive ? upper.prev_float : upper)
+
+          Type::Combinator.float_range(lower, upper, exclude_end: exclusive)
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@
 require_relative "../../reflection"
 require_relative "../../type"
 require_relative "../../rbs_extended"
+require_relative "../range_constant"
 require_relative "../rbs_type_translator"
 require_relative "../void_origin"
 require_relative "../optimistic_origin"
@@ -71,31 +72,38 @@ module Rigor
         private_constant :EMPTY_TYPE_VARS
         EMPTY_TYPE_PARAM_NAMES = [].freeze
         private_constant :EMPTY_TYPE_PARAM_NAMES
+        NO_BINDING = [nil, nil].freeze
+        private_constant :NO_BINDING
 
-        # @param receiver [Rigor::Type]
-        # @param method_name [Symbol]
-        # @param args [Array<Rigor::Type>]
-        # @param environment [Rigor::Environment]
-        # @param block_type [Rigor::Type, nil] inferred block return type, propagated from
-        #   `MethodDispatcher.dispatch`. When non-nil, the selector prefers a block-bearing overload and
-        #   binds the method-level type parameter that the block's return type references to `block_type`
-        #   (Slice 6 phase C sub-phase 2).
-        # @param self_type_override [Rigor::Type, nil] when set, the substitution for `Bases::Self` in the
-        #   method's return type. Used by `MethodDispatcher#try_user_class_fallback` to preserve the
-        #   ORIGINAL receiver as the substitute for `self` even though the dispatch is routed through
-        #   `Nominal[Object]` — so that `Bundler::URI::Generic.dup` (which resolves through the `Object`
-        #   fallback because `Bundler::URI::Generic` lacks RBS) returns `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,
+        # Both spellings a resolved `RBS::Types::ClassInstance#name` — or a `Nominal#class_name` built
+        # from one — may carry for `Range`; core signatures absolutise, but a plugin-contributed one
+        # need not.
+        RANGE_TYPE_NAMES = ["::Range", "Range"].freeze
+        private_constant :RANGE_TYPE_NAMES
+
+        # Four fields of `context` shape the answer beyond receiver, method name and arguments.
+        #
+        # `block_type` is the inferred block return type propagated from `MethodDispatcher.dispatch`; when
+        # non-nil, the selector prefers a block-bearing overload and binds the method-level type parameter
+        # that the block's return type references to it (Slice 6 phase C sub-phase 2).
+        #
+        # `self_type_override`, when set, is the substitution for `Bases::Self` in the method's return type.
+        # `MethodDispatcher#try_user_class_fallback` uses it to preserve the ORIGINAL receiver as the
+        # substitute for `self` even though the dispatch is routed through `Nominal[Object]` — so that
+        # `Bundler::URI::Generic.dup` (which resolves through the `Object` fallback because
+        # `Bundler::URI::Generic` lacks RBS) returns `Bundler::URI::Generic` per `Kernel#dup: () -> self`
+        # rather than `Object`. Nil computes self from the resolved class_name as before.
+        #
+        # `public_only`, when true, keeps a method whose RBS accessibility is `:private` from resolving (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.
+        #
+        # `scope`, when supplied, enables ADR-43 RBS-complete-ancestor resolution against
+        # `ALLOWED_RBS_COMPLETE_ANCESTORS`; `nil` keeps inherited calls unresolved (`Dynamic[Top]`) — the
+        # FP-safe default for open hierarchies (`< ActionController::Base`, …).
+        #
+        # @return inferred return type, or `nil` when no rule resolves (no class name,
         #   no method, dispatch on a Top/Dynamic[Top] receiver, etc.).
-        # @param scope [Rigor::Scope, nil] when supplied, enables ADR-43 RBS-complete-ancestor resolution
-        #   against `ALLOWED_RBS_COMPLETE_ANCESTORS`. `nil` keeps inherited calls unresolved
-        #   (`Dynamic[Top]`) — the FP-safe default for open hierarchies (`< ActionController::Base`, …).
         def try_dispatch(context)
           environment = context.environment
           return nil if environment.nil?
@@ -130,7 +138,7 @@ module Rigor
         #
         # This deliberately does NOT differentiate "no overload had a block" from "the block is untyped";
         # the binder treats both the same way (every parameter defaults to `Dynamic[Top]`).
-        # @return [Array<Rigor::Type>] positional block parameter types.
+        # @return positional block parameter types.
         def block_param_types(context)
           environment = context.environment
           return [] if environment.nil?
@@ -181,6 +189,15 @@ module Rigor
             method_definition = lookup_method(environment, class_name, kind, method_name, scope)
             return nil unless method_definition
             return nil if public_only && method_private?(method_definition)
+            # Issue #823 — a declaration that states the member's presence and parameters but not its
+            # return (`%a{rigor:v1:inferred-return}`, written by `rigor-rbs-inline` on every type slot it
+            # DEFAULTED). Declining here is the whole mechanism: this tier's product IS the return type, so
+            # withholding it routes the call down the same tiers an undeclared method takes and the body
+            # gets typed. Everything the declaration DOES say survives, because the rules that read it —
+            # `call.undefined-method`, `call.wrong-arity`, argument-type checking — look the method up in
+            # the environment themselves rather than reading this tier's answer.
+            return nil if RbsExtended.inferred_return?(method_definition)
+            return SPACESHIP_ENVELOPE if inherited_identity_spaceship?(method_definition, class_name, kind, method_name)
 
             type_vars = build_type_vars(environment, class_name, receiver_args)
             translate_return_type(
@@ -202,6 +219,46 @@ module Rigor
             nil
           end
 
+          # Issue #661 — `Kernel#<=>: (untyped other) -> 0?` is the IDENTITY comparison: `0` when the two
+          # are the same object, `nil` otherwise, and correct as written for a bare `Object`. Reached by
+          # inheritance it stops being a statement about the call. `1.day <=> 2.days` typed as `0?`, and a
+          # `Money` whose signature says `include Comparable` — whose whole contract is that the includer
+          # defines `<=>` — typed the same, because neither declares `<=>` of its own and every class
+          # inherits Kernel's.
+          #
+          # `0?` is a VALUE claim, so the cost is not confined to the expression: narrowing
+          # `n = a <=> b; n.negative? if n` reads the truthy arm as the literal `0`, folds `0.negative?`
+          # to false, and answers `bot` for a branch the runtime takes on every ordered pair. That is one
+          # `clause.unreachable` away from a false positive on correct code.
+          #
+          # Widened rather than declined: `Integer?` is the envelope Ruby's own `<=>` convention states and
+          # the one upstream rbs writes wherever a class DOES declare the operator (`Array`, `Module`,
+          # `Complex`). It is a supertype of `0?`, so this only ever removes a conclusion — and it removes
+          # exactly the conclusions that rested on the receiver not overriding an operator its signature
+          # was never required to mention (ADR-5: a partially-declared class is not a closed world).
+          #
+          # Bounded to the three classes that OWN the identity comparison, where the claim is the truth
+          # about the receiver rather than an artifact of inheritance, and to `<=>` alone — the general
+          # question of what an inherited Object/Kernel signature may assert about a subclass is much
+          # larger, and `to_s` / `hash` / `inspect` do not carry a value-precise return to lose.
+          SPACESHIP_IDENTITY_OWNERS = %w[Kernel Object BasicObject].to_set.freeze
+          private_constant :SPACESHIP_IDENTITY_OWNERS
+
+          SPACESHIP_ENVELOPE = Type::Combinator.union(
+            Type::Combinator.nominal_of("Integer"),
+            Type::Combinator.constant_of(nil)
+          ).freeze
+          private_constant :SPACESHIP_ENVELOPE
+
+          def inherited_identity_spaceship?(method_definition, class_name, kind, method_name)
+            return false unless method_name == :<=>
+            return false unless kind == :instance
+            return false if SPACESHIP_IDENTITY_OWNERS.include?(class_name.to_s.delete_prefix("::"))
+            return false unless method_definition.respond_to?(:defined_in)
+
+            SPACESHIP_IDENTITY_OWNERS.include?(method_definition.defined_in.to_s.delete_prefix("::"))
+          end
+
           # Maps a Rigor::Type receiver to a `[class_name, kind, type_args]` triple where `kind` is either
           # `:instance` or `:singleton` and `type_args` carries the receiver's generic instantiation (empty
           # for raw or singleton receivers, since `Singleton[Foo]` carries no generic args today). Returns
@@ -237,6 +294,13 @@ module Rigor
               # whole dispatch to Dynamic). The refinement-aware promotions (`String#upcase` →
               # `uppercase-string`, …) run in their own catalog tier ABOVE this one, so they still win.
               receiver_descriptor(receiver.base)
+            when Type::FloatRange
+              # ADR-109 WD4 — a bounded Float is a Float for every method the fold tiers do not own.
+              ["Float", :instance, []]
+            when Type::IntegerRange
+              # #842 — a bounded Integer is an Integer for every method the fold tiers
+              # (ConstantFolding, ShapeDispatch#dispatch_integer_range) do not own.
+              ["Integer", :instance, []]
             when Type::Dynamic
               receiver_descriptor(receiver.static_facet)
             end
@@ -331,15 +395,20 @@ module Rigor
           # disagree -- in both cases free variables in the method's return type degrade to `Dynamic[Top]`
           # per the translator's contract.
           def build_type_vars(environment, class_name, receiver_args)
-            return {} if receiver_args.empty?
+            return NO_TYPE_VARS if receiver_args.empty?
 
             param_names = Rigor::Reflection.class_type_param_names(class_name, environment: environment)
-            return {} if param_names.empty?
-            return {} if param_names.size != receiver_args.size
+            return NO_TYPE_VARS if param_names.empty?
+            return NO_TYPE_VARS if param_names.size != receiver_args.size
 
             param_names.zip(receiver_args).to_h
           end
 
+          # The shared empty substitution map: most receivers carry no type arguments, and the translator
+          # only ever reads the map (#775).
+          NO_TYPE_VARS = {}.freeze
+          private_constant :NO_TYPE_VARS
+
           # rubocop:disable Metrics/ParameterLists
           def translate_return_type(method_definition, class_name:, kind:, args:, type_vars:, block_type:,
                                     method_name: nil, environment: nil, self_type_override: nil,
@@ -505,7 +574,8 @@ module Rigor
           # Envelope, deliberately the narrowest sound shape:
           #
           # * only a positional parameter (required or optional) whose declared type is EXACTLY
-          #   `RBS::Types::Variable` — no container walk, so `(Array[T]) -> T` still degrades;
+          #   `RBS::Types::Variable`, plus the one container shape issue #834 admits (see
+          #   {#range_element_binding}) — no general container walk, so `(Array[T]) -> T` still degrades;
           # * only names the SELECTED overload declares in its own `type_params` (a class-level variable
           #   keeps its receiver-derived binding);
           # * an existing key wins, so the receiver and the block return type both outrank an argument;
@@ -534,14 +604,27 @@ module Rigor
             positionals.zip(args).each_with_object({}) do |(param, arg), bindings|
               next if arg.nil?
 
-              name = variable_param_name(param, declared, type_vars)
+              name, bound = param_binding(param, arg, declared, type_vars)
               next if name.nil?
-              next if no_static_evidence?(arg)
 
-              bindings[name] = bindings.key?(name) ? Type::Combinator.union(bindings[name], arg) : arg
+              bindings[name] = bindings.key?(name) ? Type::Combinator.union(bindings[name], bound) : bound
             end
           end
 
+          # The `(variable name, bound type)` a positional parameter contributes, or {NO_BINDING} when it
+          # contributes none. The bare-variable shape is tried first because it is the overwhelmingly
+          # common one; the `Range[A]` shape is reached only when the parameter is not a bare variable.
+          def param_binding(param, arg, declared, type_vars)
+            name = variable_param_name(param, declared, type_vars)
+            unless name.nil?
+              return NO_BINDING if no_static_evidence?(arg)
+
+              return [name, arg]
+            end
+
+            range_element_binding(param, arg, declared, type_vars)
+          end
+
           def declared_type_param_names(method_type)
             params = method_type.respond_to?(:type_params) ? method_type.type_params : nil
             return EMPTY_TYPE_PARAM_NAMES if params.nil? || params.empty?
@@ -562,6 +645,57 @@ module Rigor
             name
           end
 
+          # Issues #834 / #862 — the one container position the envelope admits: a `Range[A]` parameter
+          # against a Range argument that names its own element. `Comparable#clamp: [A] (Range[A]) ->
+          # (self | A)` otherwise leaves `A` unbound and `i.clamp(1..9)` answers `Dynamic[top] | Integer`,
+          # even though the argument names the element outright. It stays Range-only because the
+          # justification does not generalise: a Range is immutable and its element type is fixed at
+          # construction, whereas an `Array[T]` argument's carrier may have been widened long before the
+          # call reached here.
+          def range_element_binding(param, arg, declared, type_vars)
+            declared_type = param.type
+            return NO_BINDING unless declared_type.is_a?(RBS::Types::ClassInstance)
+            return NO_BINDING unless RANGE_TYPE_NAMES.include?(declared_type.name.to_s)
+            return NO_BINDING unless declared_type.args.size == 1
+
+            element = declared_type.args.first
+            return NO_BINDING unless element.is_a?(RBS::Types::Variable)
+            return NO_BINDING unless declared.include?(element.name)
+            return NO_BINDING if type_vars.key?(element.name)
+
+            bound = range_argument_element(arg)
+            bound.nil? ? NO_BINDING : [element.name, bound]
+          end
+
+          # The element a Range argument names, or nil when it names none.
+          #
+          # Two carriers qualify. A `Constant<Range>` contributes its endpoints lifted to their classes
+          # ({RangeConstant.element_type}), not the two values, so `clamp(1..9)` answers `Integer` rather
+          # than a `1 | 9` the runtime contradicts for every receiver already inside the bracket. A
+          # `Nominal[Range, [T]]` (issue #862 — `1..ARGV.size` has no literal endpoint to read, so
+          # `ExpressionTyper` hands back the nominal carrier) contributes `T` itself.
+          #
+          # A nominal carrier qualifies only when `T` is a Nominal or a union of Nominals. `untyped`, a
+          # `Dynamic`, or a still-unbound type variable would launder an unknown into the result — the
+          # caller's `self | A` would read as `self | unknown` while claiming to be inferred — so those
+          # keep degrading as an unbound variable does.
+          def range_argument_element(arg)
+            return RangeConstant.element_type(arg) unless arg.is_a?(Type::Nominal)
+            return nil unless RANGE_TYPE_NAMES.include?(arg.class_name)
+            return nil unless arg.type_args.size == 1
+
+            element = arg.type_args.first
+            nominal_only?(element) ? element : nil
+          end
+
+          def nominal_only?(type)
+            case type
+            when Type::Nominal then true
+            when Type::Union then type.members.all?(Type::Nominal)
+            else false
+            end
+          end
+
           # `Dynamic[top]` is the engine's "we could not tell" answer, so binding a variable to it would
           # dress up an absence of evidence as an inference. The variable stays unbound and degrades as it
           # did before, which is the same value anyway.