rigortype 0.3.8 → 0.3.9

data/lib/rigor/inference/narrowing.rb

@@ -41,7 +41,10 @@ module Rigor
     module Narrowing
       TRUSTED_EQUALITY_LITERAL_CLASSES = [String, Symbol, Integer, TrueClass, FalseClass, NilClass].freeze
       SINGLETON_LITERAL_CLASSES = [TrueClass, FalseClass, NilClass].freeze
-      ClassNarrowingContext = Data.define(:exact, :polarity, :environment)
+      # `scope` is the analysed file's seeded scope where the caller has one, and nil otherwise (the
+      # Fact-shaped and RSpec-matcher entries hold an environment but no scope). Only the #898 singleton
+      # path reads it, and only to withhold a `Bot`, so a nil scope is the pre-#898 answer exactly.
+      ClassNarrowingContext = Data.define(:exact, :polarity, :environment, :scope)
       # A recognised `=~` regex pattern operand: the pattern `source` string and whether it was
       # compiled in extended (`//x`) mode. Extraction from a literal `RegularExpressionNode` and from
       # a value-pinned `Constant[Regexp]` share this carrier so the participation walk and the
@@ -139,9 +142,11 @@ module Rigor
       # counterpart of the scope narrowing {.case_when_scopes} performs for the same condition
       # shape, kept here so the branch a `case` expression's type drops and the clause whose
       # body scope goes dead derive from one judgment.
-      def class_pattern_certainty(subject_type, class_name, environment:)
-        truthy_bot = narrow_class(subject_type, class_name, environment: environment).is_a?(Type::Bot)
-        falsey_bot = narrow_not_class(subject_type, class_name, environment: environment).is_a?(Type::Bot)
+      def class_pattern_certainty(subject_type, class_name, environment:, scope: nil)
+        truthy_bot = narrow_class(subject_type, class_name, environment: environment,
+                                                            scope: scope).is_a?(Type::Bot)
+        falsey_bot = narrow_not_class(subject_type, class_name, environment: environment,
+                                                                scope: scope).is_a?(Type::Bot)
 
         return :no if truthy_bot && !falsey_bot
         return :yes if !truthy_bot && falsey_bot
@@ -219,6 +224,54 @@ module Rigor
         narrow_integer_comparison_dispatch(type, comparator, bound)
       end
 
+      # Float-comparison fragment of `type` against a numeric literal `bound` (ADR-109 WD5). This
+      # is a TRUTHY-EDGE rule only: `x > c` is false for NaN, so the set that satisfies it is the
+      # range `Float[c..]`, but the set that fails it is that range's complement PLUS NaN, which no
+      # range spells. Callers apply it to the truthy edge and keep the entry type on the falsy edge.
+      # `x > c` narrows to the closed envelope `Float[c..]` rather than the exact `(c, ∞]` (one
+      # double wider; the exact form is deferred until a rule demands the removed point), `x < c`
+      # to the exact `Float[...c]`. Hooks in:
+      # - `Constant<Float>` is preserved when it satisfies the comparison, otherwise collapsed to
+      #   `Bot` (a NaN constant satisfies nothing);
+      # - `FloatRange` becomes its intersection with the half-line, `Bot` when empty;
+      # - `Nominal[Float]` becomes the half-line itself;
+      # - `Union` narrows each member independently; Integer-rooted and other carriers flow
+      #   through unchanged (the Integer rule above owns them).
+      def narrow_float_comparison(type, comparator, bound)
+        return type unless (bound.is_a?(Integer) || bound.is_a?(Float)) && %i[< <= > >=].include?(comparator)
+
+        bound = bound.to_f
+        return type if bound.nan? || bound.infinite?
+
+        narrow_float_comparison_dispatch(type, comparator, bound)
+      end
+
+      # The truthy edge of a numeric comparison: the Integer rule for Integer-rooted members, then
+      # the Float rule for Float-rooted ones. Never apply this to a falsy edge (see
+      # {.narrow_float_comparison}).
+      def narrow_numeric_comparison_truthy(type, comparator, bound)
+        narrow_float_comparison(narrow_integer_comparison(type, comparator, bound), comparator, bound)
+      end
+
+      # Intersects the Float-rooted members of `type` with `range` (a `FloatRange`), leaving every
+      # other member unchanged. `x.nan?` narrows its FALSY edge with `non_nan_float`; `x.finite?`
+      # narrows its TRUTHY edge with `finite_float`; the other edge of each keeps the entry type
+      # (NaN is truthy for `nan?` and nothing else is known there; `!finite?` admits NaN and ±∞).
+      def narrow_float_to_range(type, range)
+        case type
+        when Type::Constant
+          type.value.is_a?(Float) && !range.covers?(type.value) ? Type::Combinator.bot : type
+        when Type::FloatRange
+          intersect_float_bounds(type, range.min, range.max, range.exclude_end?)
+        when Type::Nominal
+          float_nominal?(type) ? range : type
+        when Type::Union
+          Type::Combinator.union(*type.members.map { |m| narrow_float_to_range(m, range) })
+        else
+          type
+        end
+      end
+
       # Equality fragment of `type` against an Integer `value`. `Constant<Integer>` is preserved
       # when it equals `value`, otherwise collapses to `Bot`. `IntegerRange` covers? `value`
       # narrows to `Constant[value]`; an out-of-range comparison collapses to `Bot`.
@@ -261,8 +314,9 @@ module Rigor
       # preserved; disjoint hierarchies collapse to `Bot`. Classes the environment cannot
       # resolve fall back to the conservative answer (the type unchanged) so the analyzer never
       # asserts narrowing it cannot prove.
-      def narrow_class(type, class_name, exact: false, environment: Environment.default)
-        context = ClassNarrowingContext.new(exact: exact, polarity: :positive, environment: environment)
+      def narrow_class(type, class_name, exact: false, environment: Environment.default, scope: nil)
+        context = ClassNarrowingContext.new(exact: exact, polarity: :positive, environment: environment,
+                                            scope: scope)
         narrow_class_dispatch(type, class_name, context)
       end
 
@@ -270,8 +324,9 @@ module Rigor
       # Inhabitants that DO satisfy the predicate are removed; inhabitants that do not are
       # preserved. Conservative on Top/Dynamic/Bot (preserved unchanged) because the analyzer
       # cannot prove the negative without a richer carrier.
-      def narrow_not_class(type, class_name, exact: false, environment: Environment.default)
-        context = ClassNarrowingContext.new(exact: exact, polarity: :negative, environment: environment)
+      def narrow_not_class(type, class_name, exact: false, environment: Environment.default, scope: nil)
+        context = ClassNarrowingContext.new(exact: exact, polarity: :negative, environment: environment,
+                                            scope: scope)
         narrow_class_dispatch(type, class_name, context)
       end
 
@@ -285,11 +340,11 @@ module Rigor
       #   Walk the current type's union members, keep each part disjoint from `base`, and add
       #   the removed-value Constant once when any current member covers it. `assert s is
       #   ~non-empty-string` over `s: String | nil` narrows to `Constant[""] | NilClass`.
-      # - `IntegerRange[a, b]` (v0.0.5+ slice). Complement is the two open halves `int<min,
-      #   a-1>` and `int<b+1, max>`, each intersected with the integer-domain parts of
+      # - `IntegerRange[a, b]` (v0.0.5+ slice). Complement is the two open halves
+      #   `Integer[..a-1]` and `Integer[b+1..]`, each intersected with the integer-domain parts of
       #   `current_type`. Non-integer parts (nil, String, …) of a Union receiver survive
-      #   unchanged. `assert n is ~int<5, 10>` over `n: Integer | nil` narrows to `int<min, 4> |
-      #   int<11, max> | NilClass`.
+      #   unchanged. `assert n is ~Integer[5..10]` over `n: Integer | nil` narrows to `Integer[..4] |
+      #   Integer[11..] | NilClass`.
       # - `Type::Intersection[M1, M2, …]` (v0.0.5+ slice). De Morgan: `D \ (M1 ∩ M2) = (D \ M1)
       #   ∪ (D \ M2)`. Each member's complement is computed independently within
       #   `current_type` and the results are unioned. Members the algebra cannot complement
@@ -337,10 +392,6 @@ module Rigor
 
       # Public predicate analyser. Returns `[truthy_scope, falsey_scope]`, always; when no
       # narrowing rule matches the predicate node both entries are the receiver scope unchanged.
-      #
-      # @param node [Prism::Node, nil]
-      # @param scope [Rigor::Scope]
-      # @return [Array(Rigor::Scope, Rigor::Scope)]
       def predicate_scopes(node, scope)
         return [scope, scope] if node.nil?
 
@@ -366,11 +417,9 @@ module Rigor
       # constants narrow as `is_a?`; integer/float-endpoint ranges narrow to `Numeric`;
       # string-endpoint ranges and regexp literals narrow to `String`.
       #
-      # @param subject [Prism::Node, nil] the `case` subject.
-      # @param conditions [Array<Prism::Node>] the `when`
+      # @param subject — the `case` subject.
+      # @param conditions — the `when`
       #   clause's `conditions` array.
-      # @param scope [Rigor::Scope]
-      # @return [Array(Rigor::Scope, Rigor::Scope)]
       def case_when_scopes(subject, conditions, scope)
         # C1 — `case x when /re/` runs `/re/ === x`, which sets the regex match-data globals
         # exactly as a successful `=~` does. Narrow `$~`/`$&`/`$1..$N` on the clause body (the
@@ -480,7 +529,7 @@ module Rigor
         end
 
         # Complement of an `IntegerRange[a, b]` within `current_type`. Splits the range
-        # complement into the two open halves `int<min, a-1>` and `int<b+1, max>` (skipping a
+        # complement into the two open halves `Integer[..a-1]` and `Integer[b+1..]` (skipping a
         # half when its bound is infinity), then intersects each half with the integer-domain
         # parts of `current_type`. Non-integer parts of a Union receiver (nil, String, …)
         # survive unchanged.
@@ -505,8 +554,8 @@ module Rigor
           Type::Combinator.union(*survivors)
         end
 
-        # Returns the two open halves of an IntegerRange's complement: the left half `int<-∞,
-        # a-1>` (when `a` is finite) and the right half `int<b+1, ∞>` (when `b` is finite).
+        # Returns the two open halves of an IntegerRange's complement: the left half
+        # `Integer[..a-1]` (when `a` is finite) and the right half `Integer[b+1..]` (when `b` is finite).
         # Universal ranges (both bounds infinite) yield an empty array — the complement is
         # empty.
         def integer_range_complement_halves(range)
@@ -994,7 +1043,7 @@ module Rigor
 
         def simple_dispatch_name?(name)
           %i[nil? ! is_a? kind_of? instance_of? == != === =~ match? key? has_key? empty? any?
-             none? respond_to?].include?(name)
+             none? respond_to? nan? finite?].include?(name)
         end
 
         def dispatch_call_simple(node, scope, name)
@@ -1009,6 +1058,7 @@ module Rigor
           when :key?, :has_key? then analyse_key_presence_predicate(node, scope)
           when :empty?, :any?, :none? then analyse_array_emptiness_predicate(node, scope, name)
           when :respond_to? then analyse_respond_to_predicate(node, scope)
+          when :nan?, :finite? then analyse_float_class_predicate(node, scope, name)
           end
         end
 
@@ -1551,19 +1601,41 @@ module Rigor
           return nil unless node.arguments.arguments.size == 2
 
           low, high = node.arguments.arguments
-          return nil unless low.is_a?(Prism::IntegerNode) && high.is_a?(Prism::IntegerNode)
+          return nil unless numeric_literal_node?(low) && numeric_literal_node?(high)
 
           local_name = node.receiver.name
           current = scope.local(local_name)
           return nil if current.nil?
 
-          truthy = narrow_integer_comparison(
-            narrow_integer_comparison(current, :>=, low.value),
+          # Truthy edge only, for Integer and Float members alike (ADR-109 WD5): a Float literal
+          # bound leaves the Integer members untouched, and vice versa.
+          truthy = narrow_numeric_comparison_truthy(
+            narrow_numeric_comparison_truthy(current, :>=, low.value),
             :<=, high.value
           )
           [scope.with_local(local_name, truthy), scope]
         end
 
+        # `x.nan?` / `x.finite?` (ADR-109 WD5). `nan?` narrows the FALSY edge to the non-NaN Floats
+        # and leaves the truthy edge alone (NaN is not a carrier); `finite?` narrows the TRUTHY
+        # edge to the finite Floats and leaves the falsy edge alone (it admits NaN and ±∞). A
+        # non-Float member is untouched on both edges.
+        def analyse_float_class_predicate(node, scope, predicate)
+          return nil unless argument_free?(node)
+          return nil unless node.receiver.is_a?(Prism::LocalVariableReadNode)
+
+          local_name = node.receiver.name
+          current = scope.local(local_name)
+          return nil if current.nil?
+
+          case predicate
+          when :nan?
+            [scope, scope.with_local(local_name, narrow_float_to_range(current, Type::Combinator.non_nan_float))]
+          when :finite?
+            [scope.with_local(local_name, narrow_float_to_range(current, Type::Combinator.finite_float)), scope]
+          end
+        end
+
         # Helper for {.narrow_integer_not_equal}. Only adjusts when the value sits exactly on
         # one endpoint, so the result stays contiguous; otherwise the input range is preserved.
         def narrow_integer_range_not_equal(range, value)
@@ -1628,20 +1700,96 @@ module Rigor
           current = scope.local(local_name)
           return nil if current.nil?
 
-          truthy = narrow_integer_comparison(current, normalised_op, bound)
+          # ADR-109 WD5 — the Float rule runs on the truthy edge only: the falsy edge of `x > c`
+          # admits NaN, so its Float-rooted members keep the entry type (the Integer rule below
+          # leaves them untouched by construction).
+          truthy = narrow_numeric_comparison_truthy(current, normalised_op, bound)
           falsey = narrow_integer_comparison(current, INVERT_COMPARISON_OP[normalised_op], bound)
           [scope.with_local(local_name, truthy), scope.with_local(local_name, falsey)]
         end
 
+        # An Integer or Float literal. Prism folds a leading minus into the literal, so `-1.5` is one
+        # `FloatNode`.
+        def numeric_literal_node?(node)
+          node.is_a?(Prism::IntegerNode) || node.is_a?(Prism::FloatNode)
+        end
+
         def comparison_local_literal(left, right, comparator)
-          if left.is_a?(Prism::LocalVariableReadNode) && right.is_a?(Prism::IntegerNode)
+          if left.is_a?(Prism::LocalVariableReadNode) && numeric_literal_node?(right)
             return [left.name, comparator, right.value]
           end
-          return nil unless right.is_a?(Prism::LocalVariableReadNode) && left.is_a?(Prism::IntegerNode)
+          return nil unless right.is_a?(Prism::LocalVariableReadNode) && numeric_literal_node?(left)
 
           [right.name, REVERSE_COMPARISON_OP[comparator], left.value]
         end
 
+        def narrow_float_comparison_dispatch(type, comparator, bound)
+          case type
+          when Type::Constant
+            # A non-Float constant belongs to another rule and is never dropped here. The test is
+            # the positive comparison, negated once: NaN fails every comparison, which is Ruby's
+            # answer too, and rewriting `!(v < c)` as `v >= c` would silently let NaN through.
+            return type unless type.value.is_a?(Float)
+
+            float_constant_satisfies?(type.value, comparator, bound) ? type : Type::Combinator.bot
+          when Type::FloatRange
+            lo, hi, hi_exclusive = float_comparison_half_line(comparator, bound)
+            intersect_float_bounds(type, lo, hi, hi_exclusive)
+          when Type::Nominal
+            return type unless float_nominal?(type)
+
+            lo, hi, hi_exclusive = float_comparison_half_line(comparator, bound)
+            intersect_float_bounds(Type::Combinator.non_nan_float, lo, hi, hi_exclusive)
+          when Type::Union
+            Type::Combinator.union(
+              *type.members.map { |m| narrow_float_comparison_dispatch(m, comparator, bound) }
+            )
+          else
+            type
+          end
+        end
+
+        def float_nominal?(nominal)
+          nominal.class_name == "Float" && nominal.type_args.empty?
+        end
+
+        def float_constant_satisfies?(value, comparator, bound)
+          case comparator
+          when :<  then value < bound
+          when :<= then value <= bound
+          when :>  then value > bound
+          when :>= then value >= bound
+          end
+        end
+
+        # `[lo, hi]` with `hi` exclusive or not: `x < c` is `[-∞, c)`, `x <= c` is `[-∞, c]`, and both
+        # `x > c` and `x >= c` are the closed envelope `[c, ∞]` (WD5).
+        def float_comparison_half_line(comparator, bound)
+          case comparator
+          when :<  then [-Float::INFINITY, bound, true]
+          when :<= then [-Float::INFINITY, bound, false]
+          else          [bound, Float::INFINITY, false]
+          end
+        end
+
+        # Intersects `range` with `[lo, hi]` (`hi` exclusive when `hi_exclusive`), keeping whichever
+        # upper bound is tighter on the canonical closed form together with its own exclusivity, so
+        # `Float[0.0...1.0] ∩ [-∞, 2.0]` still displays `Float[0.0...1.0]`. Empty is `Bot`.
+        def intersect_float_bounds(range, lower, upper, upper_exclusive)
+          new_min = [range.min, lower].max
+          half_canonical_max = upper_exclusive ? upper.prev_float : upper
+          if half_canonical_max < range.canonical_max
+            new_max = upper
+            exclusive = upper_exclusive
+          else
+            new_max = range.max
+            exclusive = range.exclude_end?
+          end
+          return Type::Combinator.bot if new_min > (exclusive ? new_max.prev_float : new_max)
+
+          Type::Combinator.float_range(new_min, new_max, exclude_end: exclusive)
+        end
+
         def narrow_integer_equal_dispatch(type, value)
           case type
           when Type::Constant then narrow_integer_equal_constant(type, value)
@@ -1854,8 +2002,10 @@ module Rigor
           current = scope.type_of(node.receiver)
           return nil if current.nil?
 
-          truthy_type = narrow_class(current, class_name, exact: exact, environment: scope.environment)
-          falsey_type = narrow_not_class(current, class_name, exact: exact, environment: scope.environment)
+          truthy_type = narrow_class(current, class_name, exact: exact, environment: scope.environment,
+                                                          scope: scope)
+          falsey_type = narrow_not_class(current, class_name, exact: exact, environment: scope.environment,
+                                                              scope: scope)
 
           [
             scope.with_method_chain_narrowing(*address, truthy_type),
@@ -1907,13 +2057,25 @@ module Rigor
         # shapes at once. Because the repair lives in the shared derivation, `is_a?`, `case`/`when`, `===`
         # and the constant typer were fixed together rather than one guard shape at a time. A scope no
         # declaration walk built still falls back to the peel; see {Reflection.lexical_nesting_chain}.
+        #
+        # A path whose head and tail have DIFFERENT owners is the one shape no `<prefix>::<full path>`
+        # candidate can name (#656), so the whole-path loop falls through to the segment-wise walk
+        # before it gives up: `A::B` guarded inside `P::Guard` with `P::A < P::Base` is `P::Base::B`,
+        # which the loop above only ever reached as the top-level `A::B` — a real but different class,
+        # and every reader call on the narrowed receiver was then checked against it. The walk is
+        # {Reflection.resolve_constant_path_name}, shared with the constant typer so the guard and the
+        # value it guards cannot name two classes, and it takes this scope's acceptance test so a
+        # candidate is still adopted only when the environment or discovery knows it as a class.
         def resolve_class_name_lexically(bare_name, scope)
           chain = lexical_nesting_for(scope)
           chain.each do |prefix|
             candidate = "#{prefix}::#{bare_name}"
             return candidate if class_known_to_scope?(scope, candidate)
           end
-          bare_name
+          walked = Reflection.resolve_constant_path_name(bare_name, scope) do |candidate|
+            class_known_to_scope?(scope, candidate)
+          end
+          walked || bare_name
         end
 
         # Combines the environment's RBS-known set with the scope's in-source
@@ -1937,11 +2099,11 @@ module Rigor
           [
             scope.with_local(
               name,
-              narrow_class(current, class_name, exact: exact, environment: scope.environment)
+              narrow_class(current, class_name, exact: exact, environment: scope.environment, scope: scope)
             ),
             scope.with_local(
               name,
-              narrow_not_class(current, class_name, exact: exact, environment: scope.environment)
+              narrow_not_class(current, class_name, exact: exact, environment: scope.environment, scope: scope)
             )
           ]
         end
@@ -1996,8 +2158,10 @@ module Rigor
           current = scope.type_of(chain_arg)
           return nil if current.nil?
 
-          truthy_type = narrow_class(current, class_name, exact: false, environment: scope.environment)
-          falsey_type = narrow_not_class(current, class_name, exact: false, environment: scope.environment)
+          truthy_type = narrow_class(current, class_name, exact: false, environment: scope.environment,
+                                                          scope: scope)
+          falsey_type = narrow_not_class(current, class_name, exact: false, environment: scope.environment,
+                                                              scope: scope)
           [
             scope.with_method_chain_narrowing(*address, truthy_type),
             scope.with_method_chain_narrowing(*address, falsey_type)
@@ -2012,7 +2176,8 @@ module Rigor
           target_class = case_equality_target_class(receiver)
           return nil if target_class.nil?
 
-          narrowed = narrow_class(current, target_class, exact: false, environment: scope.environment)
+          narrowed = narrow_class(current, target_class, exact: false, environment: scope.environment,
+                                                         scope: scope)
           [
             scope.with_local(local_name, narrowed),
             scope.with_local(local_name, current)
@@ -2283,8 +2448,9 @@ module Rigor
 
         def class_when_result(scope, current, target, falsey_acc)
           {
-            truthy: narrow_class(current, target, exact: false, environment: scope.environment),
-            falsey: narrow_not_class(falsey_acc, target, exact: false, environment: scope.environment),
+            truthy: narrow_class(current, target, exact: false, environment: scope.environment, scope: scope),
+            falsey: narrow_not_class(falsey_acc, target, exact: false, environment: scope.environment,
+                                                         scope: scope),
             fully_narrowable: true
           }
         end
@@ -2368,6 +2534,11 @@ module Rigor
         # through {#rooted_class_predicate_name}, which layers #614's extra decline on top of the
         # same walk. A rooted `::Foo` names the top level and never a lexically nearer shadow, so
         # it keeps the un-walked spelling. nil for any non-constant shape, as before.
+        #
+        # PUBLIC, alone among the helpers in this block (#655): `case`/`when`'s VALUE side lives in
+        # `ExpressionTyper` and matched on the as-written spelling, so the two halves of one `case`
+        # disagreed — the flow side narrowed through this walk while the value side resolved the
+        # pattern against whatever the environment knew under that literal name.
         def lexical_class_name(node, scope)
           bare_name = static_class_name(node)
           return nil if bare_name.nil?
@@ -2375,6 +2546,7 @@ module Rigor
 
           resolve_class_name_lexically(bare_name, scope)
         end
+        public :lexical_class_name
 
         # ----- narrow_class / narrow_not_class helpers -----
 
@@ -2437,8 +2609,7 @@ module Rigor
         end
 
         # Issue #657 — `Bot` is the assertion "this can never match", and only a KNOWN-disjoint ordering
-        # supports it. `subclass_of?` folds `:disjoint` and `:unknown` into one `false`, which is safe on
-        # the negative edge (where the pre-state survives) and an over-claim on the positive one:
+        # supports it (the reason {#declines_bot?} exists, and the repro it was written against):
         #
         #   module Taggable; def tag = "t"; end
         #   class Integer; include Taggable; end
@@ -2460,8 +2631,7 @@ module Rigor
         def narrow_constant_to_class(constant, class_name, context)
           rigor_class = constant.value.class.name
           return constant if subclass_of?(rigor_class, class_name, context)
-          return Type::Combinator.untyped if !context.exact &&
-                                             class_ordering(rigor_class, class_name, context) == :unknown
+          return Type::Combinator.untyped if declines_bot?(rigor_class, class_name, context)
 
           Type::Combinator.bot
         end
@@ -2505,8 +2675,14 @@ module Rigor
           end
         end
 
+        # A shape projects to `Array` / `Hash`, and reopening either of those to include a project module
+        # leaves the ordering `:unknown` for the same reason #657's `Integer` does — so `[1, 2]` under `when
+        # Taggable` reached the same unsupported `Bot`. The carrier differs; the missing evidence does not.
         def narrow_shape_to_class(shape, projected_class, class_name, context)
-          subclass_of?(projected_class, class_name, context) ? shape : Type::Combinator.bot
+          return shape if subclass_of?(projected_class, class_name, context)
+          return Type::Combinator.untyped if declines_bot?(projected_class, class_name, context)
+
+          Type::Combinator.bot
         end
 
         def narrow_shape_not_class(shape, projected_class, class_name, context)
@@ -2517,8 +2693,69 @@ module Rigor
         # subclass of `Module`). Asking `Foo.is_a?(Class)` returns true; `Foo.is_a?(Foo)`
         # returns false unless `Foo` is `Class` itself. We approximate this by treating
         # singletons uniformly as `Class` instances.
+        #
+        # The approximation answers through `Class`, so a target `Class` cannot be ordered against — a
+        # project module, typically — lands on the same `:unknown` #657 collapsed to `Bot`, and `case Widget
+        # when Meta` was reported unreachable where `Widget` had `extend Meta`.
+        #
+        # Issue #898 — that decline is silent about a target the environment DOES order against `Class`, and
+        # `extend Comparable` is one: both names are in RBS, neither includes the other, so the ordering says
+        # `:disjoint` and the collapse fired on an arm MRI takes (`Widget.is_a?(Comparable)` is true — the
+        # `extend` put `Comparable` in `Widget`'s SINGLETON ancestry, which asking about `Class` cannot see).
+        # {#singleton_extend_declines_bot?} supplies the missing half from the project's own `extend` record.
         def narrow_singleton_to_class(singleton, class_name, context)
-          subclass_of?("Class", class_name, context) ? singleton : Type::Combinator.bot
+          return singleton if subclass_of?("Class", class_name, context)
+          return Type::Combinator.untyped if declines_bot?("Class", class_name, context)
+          return Type::Combinator.untyped if singleton_extend_declines_bot?(singleton, class_name, context)
+
+          Type::Combinator.bot
+        end
+
+        # Whether the class object's own `extend` record forbids the `Bot` the `Class` approximation would
+        # otherwise authorise (#898). An extended `M` puts every ancestor of `M` in the singleton's
+        # ancestry, so the question per extended module is `M <= target`: `:equal` (`extend Comparable`
+        # under `when Comparable`) and `:subclass` support the arm, and `:unknown` (`extend Meta` under
+        # `when Comparable`, `Meta` being project source the environment never joined to RBS) cannot rule
+        # it out. `:superclass` and `:disjoint` support NOTHING and must keep the collapse — `Integer`
+        # under `when Integer` orders `:superclass` against an extended `Comparable`, and reading that as
+        # support would retract `case Widget when Integer` from every class that extends a core module.
+        #
+        # The answer is `Dynamic[top]`, never the preserved `Singleton[C]`, and the negative edge
+        # ({#narrow_singleton_not_class}) is untouched — so this record is read ONLY to withhold a claim,
+        # never to make one. That asymmetry is deliberate, and it is what keeps the fix honest against an
+        # extend record that is structurally incomplete: `Widget.extend(m)` at a call site and an `extend`
+        # written in a file outside the analysed set are both invisible to the walk behind
+        # {Scope#singleton_extends_of}, and the declaration-side record joined to it below is no more
+        # complete — RBS says nothing about a class it does not declare. A shape that turned this table into a positive
+        # `:subclass` verdict would have to be right about ABSENCE too, and it cannot be. Preserving
+        # `Singleton[C]` would also hand the arm a receiver whose singleton method table has no `clamp` on
+        # it, trading the unreachable-clause false positive for an undefined-method one — the same trap
+        # #657 recorded on the `Constant` carrier.
+        #
+        # Issue #915 — two sources, read as one. The source record above sees only what Ruby source spells;
+        # a project that declares `extend M` in its own `sig/` puts the same module in the same singleton
+        # ancestry, and the environment's declaration-side answer
+        # ({Environment#singleton_extended_modules}) is consulted alongside it. Neither is asked to be
+        # complete; each can only add a module that IS there, which is all the one-directional read needs.
+        def singleton_extend_declines_bot?(singleton, class_name, context)
+          return false if context.exact
+
+          extended = singleton_ancestor_modules(singleton, context)
+          return false if extended.empty?
+
+          extended.any? do |module_name|
+            %i[equal subclass unknown].include?(class_ordering(module_name, class_name, context))
+          end
+        end
+
+        def singleton_ancestor_modules(singleton, context)
+          scope = context.scope
+          from_source = scope.nil? ? [] : scope.singleton_extends_of(singleton.class_name)
+          from_rbs = context.environment&.singleton_extended_modules(singleton.class_name) || []
+          return from_source if from_rbs.empty?
+          return from_rbs if from_source.empty?
+
+          from_source | from_rbs
         end
 
         def narrow_singleton_not_class(singleton, class_name, context)
@@ -2534,6 +2771,22 @@ module Rigor
           end
         end
 
+        # Whether the positive edge must decline the `Bot` that `subclass_of?` returning false would
+        # otherwise authorise (#657). `subclass_of?` folds `:disjoint` and `:unknown` into one `false`, and
+        # only the first is evidence that the guard can never match; the second is the environment saying it
+        # cannot tell, which any file reopening either side can make true.
+        #
+        # This only ever ADDS a decline: every caller keeps its own `subclass_of?` test first, so the
+        # preserving edge is untouched, and a `:disjoint`, `:equal`, `:subclass` or `:superclass` verdict
+        # never reaches here. There is no ordering it turns INTO a match — the honest answer for
+        # "cannot tell" is Dynamic, never the asked class.
+        #
+        # `instance_of?` is exempt because it compares the exact class: a module is never an object's class,
+        # so that edge's `Bot` rests on the guard's own semantics rather than on the ordering.
+        def declines_bot?(rigor_class_name, target_class_name, context)
+          !context.exact && class_ordering(rigor_class_name, target_class_name, context) == :unknown
+        end
+
         # Returns `true` when an instance of `rigor_class_name` satisfies
         # `is_a?(target_class_name)` (or `instance_of?(target_class_name)` when `exact: true`).
         # Falls back to the safe `false` when either name does not resolve through the analyzer

data/lib/rigor/inference/optimistic_origin.rb

@@ -53,10 +53,6 @@ module Rigor
       # Resolution order — the mark recorded on the node itself, then the binding a bare local / ivar read (or
       # a write in value position, `if (x = MAP[k])`) resolves through, then the predicate-fold derivation
       # issue #313 added.
-      #
-      # @param node [Prism::Node, nil]
-      # @param scope [Rigor::Scope, nil]
-      # @return [Symbol, nil]
       def resolve(node, scope)
         return nil if node.nil? || scope.nil?
 
@@ -97,9 +93,7 @@ module Rigor
       # per-overload, which is what makes it precise: `Array#first` is optimistic while `Array#first(3)` is
       # not, and `String#[]` / `Enumerable#find` are honest because they already spell the miss as `?`.
       #
-      # @param method_definition [RBS::Definition::Method]
-      # @param method_type [RBS::MethodType] the overload {OverloadSelector.select} returned
-      # @return [Boolean]
+      # @param method_type — the overload {OverloadSelector.select} returned
       def optimistic_overload?(method_definition, method_type)
         type_def = matching_type_def(method_definition, method_type)
         return false unless type_def.respond_to?(:overload_annotations)

data/lib/rigor/inference/origin_lookup.rb

@@ -18,9 +18,8 @@ module Rigor
     module OriginLookup
       module_function
 
-      # @param scope [Rigor::Scope]
-      # @param node [Prism::Node, nil] the receiver expression's node (nil for an implicit-self receiver)
-      # @return [Symbol, nil] the effective dynamic-origin cause, or nil when none is known
+      # @param node — the receiver expression's node (nil for an implicit-self receiver)
+      # @return the effective dynamic-origin cause, or nil when none is known
       def origin_for(scope, node)
         return nil if node.nil?
 

data/lib/rigor/inference/parameter_inference_collector.rb

@@ -116,11 +116,10 @@ module Rigor
       # single-level pass.
       DEFAULT_ROUNDS = 3
 
-      # @param files [Array<String>] project `.rb` paths to scan for call sites.
-      # @param environment [Rigor::Environment]
-      # @param target_ruby [String, nil] Prism parse target.
-      # @param max_rounds [Integer] the WD5 fixpoint cap (1 = single-level).
-      # @return [Hash{[String,Symbol,Symbol] => Hash{Symbol => Rigor::Type}}] frozen.
+      # @param files — project `.rb` paths to scan for call sites.
+      # @param target_ruby — Prism parse target.
+      # @param max_rounds — the WD5 fixpoint cap (1 = single-level).
+      # @return => Hash{Symbol => Rigor::Type}}] frozen.
       def self.collect(files:, environment:, target_ruby: nil, max_rounds: DEFAULT_ROUNDS, workers: 0)
         new(files: files, environment: environment, target_ruby: target_ruby,
             max_rounds: max_rounds, workers: workers).collect
@@ -330,7 +329,7 @@ module Rigor
           arg.is_a?(Prism::AssocSplatNode)
       end
 
-      # @return [[String, Symbol, Symbol, Prism::DefNode], nil]
+      # @return , nil]
       def resolve_callee(call_node, scope, index)
         if call_node.receiver.nil?
           class_name, kind = implicit_self_target(scope)

data/lib/rigor/inference/pre_eval_constants.rb

@@ -92,13 +92,13 @@ module Rigor
 
       # Collects and widens the constants every `pre_eval:` file declares.
       #
-      # @param paths [Array<String>] absolute paths to the `pre_eval:` files that exist on disk.
-      # @param scope_builder [#call] `path -> Rigor::Scope`; the caller supplies a project-seeded, environment-
+      # @param paths — absolute paths to the `pre_eval:` files that exist on disk.
+      # @param scope_builder — `path -> Rigor::Scope`; the caller supplies a project-seeded, environment-
       #   bound scope so the rvalue typer resolves cross-file classes exactly as per-file analysis would.
-      # @param target_ruby [String, nil] the Prism parse version (`Configuration#target_ruby`).
-      # @param buffer [Rigor::Analysis::BufferBinding, nil] editor-mode binding; when set, a listed file that
+      # @param target_ruby — the Prism parse version (`Configuration#target_ruby`).
+      # @param buffer — editor-mode binding; when set, a listed file that
       #   matches the in-flight buffer is read from its physical bytes.
-      # @return [Hash{String => Rigor::Type}] frozen qualified-name -> published type table.
+      # @return frozen qualified-name -> published type table.
       def collect(paths:, scope_builder:, target_ruby: nil, buffer: nil)
         published = {}
         conflicted = {}
@@ -165,6 +165,7 @@ module Rigor
         when Type::Constant then widen_constant(type)
         when Type::Refined then widen(type.base)
         when Type::IntegerRange then Type::Combinator.nominal_of("Integer")
+        when Type::FloatRange then Type::Combinator.nominal_of("Float")
         when Type::Tuple then Type::Combinator.nominal_of("Array")
         when Type::HashShape then Type::Combinator.nominal_of("Hash")
         when Type::Nominal then type.type_args.empty? ? type : Type::Combinator.nominal_of(type.class_name)