rigortype 0.4.3 → 0.4.5

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

@@ -190,6 +190,35 @@ module Rigor
 
         STRING_FOLD_BYTE_LIMIT = 4096
 
+        # #2115 — the numeric twin of `STRING_FOLD_BYTE_LIMIT`. A folded Integer (and each Integer part of a
+        # folded Rational / Complex) is at most this many bits, the largest bit length whose decimal
+        # rendering still fits in `STRING_FOLD_BYTE_LIMIT` digits: `2 ** 13_605` folds, `2 ** 13_606`
+        # (bit length 13_607) does not. Computing `2 ** 100_000_000` takes Ruby milliseconds, but
+        # rendering it in decimal — which describing, sorting and printing the `Constant` does — takes
+        # minutes. `**` / `pow` / `<<` / `>>` also check their operands before invoking, so the big value
+        # is never computed.
+        INTEGER_FOLD_BIT_LIMIT = (STRING_FOLD_BYTE_LIMIT * Math.log2(10)).floor
+
+        # #2115 — the most elements a fold walks out of a `Constant<Range>` receiver. A method that
+        # enumerates the range (`to_a`, `to_set`, `all?`, `include?` on a String range, …) declines when
+        # the range holds more elements, or is endless (`1..Float::INFINITY`); a method that reads only
+        # the endpoints (`RANGE_ENDPOINT_METHODS`) still folds whatever the range's size.
+        RANGE_ENUMERATION_LIMIT = 1024
+
+        # The `Range` methods whose CRuby body reads the endpoints without walking the elements, so they
+        # stay foldable on a range past `RANGE_ENUMERATION_LIMIT`. `include?` / `member?` join them on a
+        # numeric range, where CRuby answers them by `cover?`.
+        RANGE_ENDPOINT_METHODS = Set[
+          :begin, :end, :exclude_end?, :cover?, :===, :size, :to_s, :inspect, :==, :eql?, :hash
+        ].freeze
+        RANGE_COVER_METHODS = Set[:include?, :member?].freeze
+        private_constant :RANGE_ENDPOINT_METHODS, :RANGE_COVER_METHODS
+
+        # A result `INTEGER_FOLD_BIT_LIMIT` keeps from becoming a `Constant`: the fold still knows its class,
+        # and answers `Nominal[class_name]` for it. Falling through to RBS instead would read `Integer#**`'s
+        # declared `Numeric`, on which `(2 ** 20_000).even?` is an undefined method.
+        WidenedResult = Data.define(:class_name)
+
         # Input cartesian product hard cap. Keeps fold cost bounded even when the receiver and argument are
         # both `Union[Constant…]`. 5 × 5 = 25 inputs is permitted; 6 × 6 = 36 is not. The user-facing payoff
         # (a precise small enum) drops off fast past this range and CRuby method invocation cost adds up.
@@ -649,45 +678,41 @@ module Rigor
         def range_constant_unary(range, method_name)
           case method_name
           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)
+          # #2115 — `Range#min` / `#max` / `#minmax` / `#size` are O(1) on Integer endpoints in CRuby, so
+          # none of these materialises the range. The no-arg `first` / `last` read the endpoints, not the
+          # elements: `first` is `begin` and `last` is `end` whether the range is empty, reversed or
+          # exclusive (`(5..1).first` is 5, `(1...10).last` is 10). Only `min` / `max` depend on emptiness
+          # and exclusivity (`(5..1).min` is nil, `(1...10).max` is 9).
+          when :first then Type::Combinator.constant_of(range.begin)
+          when :last then Type::Combinator.constant_of(range.end)
+          when :min then Type::Combinator.constant_of(range.min)
+          when :max then Type::Combinator.constant_of(range.max)
+          when :count, :size, :length then Type::Combinator.constant_of(range.size)
+          when :minmax then Type::Combinator.tuple_of(*range.minmax.map { |v| Type::Combinator.constant_of(v) })
           # `range.sum` is closed-form (Gauss) for an integer range, so a huge range still costs O(1) and
-          # yields a single Integer — no materialisation, no cap needed. Endless ranges are already excluded
-          # by the Integer-endpoint guard in the caller.
-          when :sum then Type::Combinator.constant_of(range.sum)
+          # yields a single Integer — no materialisation; only `INTEGER_FOLD_BIT_LIMIT` applies. Endless
+          # ranges are already excluded by the Integer-endpoint guard in the caller.
+          when :sum then range_sum_constant(range)
           end
         end
 
-        def range_to_a_tuple(range)
-          values = range.to_a
-          return Type::Combinator.tuple_of if values.empty?
-          return nil if values.size > RANGE_TO_A_LIMIT
+        # The Gauss sum of a range of large endpoints can still pass `INTEGER_FOLD_BIT_LIMIT`; it is then
+        # an `Integer` (both endpoints are).
+        def range_sum_constant(range)
+          sum = range.sum
+          return Type::Combinator.nominal_of("Integer") if oversized_number?(sum)
 
-          Type::Combinator.tuple_of(*values.map { |v| Type::Combinator.constant_of(v) })
+          Type::Combinator.constant_of(sum)
         end
 
-        def range_endpoint_constant(range, edge)
-          values = range.to_a
-          return Type::Combinator.constant_of(nil) if values.empty?
-
-          Type::Combinator.constant_of(edge == :first ? values.first : values.last)
-        end
+        def range_to_a_tuple(range)
+          # `Range#size` is O(1) on Integer endpoints: check the cardinality before materialising.
+          return nil if range.size > RANGE_TO_A_LIMIT
 
-        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
+          return Type::Combinator.tuple_of if values.empty?
 
-          Type::Combinator.tuple_of(
-            Type::Combinator.constant_of(values.first),
-            Type::Combinator.constant_of(values.last)
-          )
+          Type::Combinator.tuple_of(*values.map { |v| Type::Combinator.constant_of(v) })
         end
 
         # `(1..10).first(3)` / `.take(3)` / `.last(3)` — the 1-arg head / tail forms. `first`/`last` already
@@ -1175,6 +1200,17 @@ module Rigor
         # "Integer-ness" was already implied by the inputs (so the widening fallback only fires for
         # arithmetic over integers).
         def build_constant_type(values, source: nil)
+          widened, values = values.partition { |value| value.is_a?(WidenedResult) }
+          return build_scalar_constant_type(values, source) if widened.empty?
+
+          nominals = widened.map(&:class_name).uniq.map { |name| Type::Combinator.nominal_of(name) }
+          return Type::Combinator.union(*nominals) if values.empty?
+
+          constants = build_scalar_constant_type(values, source)
+          constants && Type::Combinator.union(constants, *nominals)
+        end
+
+        def build_scalar_constant_type(values, source)
           return nil if values.empty?
 
           unique = values.uniq
@@ -1607,9 +1643,12 @@ module Rigor
         # `flat_map`.
         def invoke_binary(receiver_value, method_name, arg_value)
           return nil unless safe?(receiver_value, method_name, arg_value)
+          return nil if range_enumeration_blow_up?(receiver_value, method_name)
 
-          result = receiver_value.public_send(method_name, arg_value)
-          foldable_constant_value?(result) ? [result] : nil
+          widened = numeric_blow_up_class(receiver_value, method_name, arg_value)
+          return [WidenedResult.new(widened)] if widened
+
+          fold_result(receiver_value.public_send(method_name, arg_value))
         rescue StandardError
           nil
         end
@@ -1620,8 +1659,7 @@ module Rigor
         def invoke_ternary(receiver_value, method_name, av0, av1)
           return nil unless ternary_method_allowed?(receiver_value, method_name)
 
-          result = receiver_value.public_send(method_name, av0, av1)
-          foldable_constant_value?(result) ? [result] : nil
+          fold_result(receiver_value.public_send(method_name, av0, av1))
         rescue StandardError
           nil
         end
@@ -1630,13 +1668,21 @@ module Rigor
         def invoke_unary(receiver_value, method_name)
           return nil unless unary_safe?(receiver_value, method_name)
           return nil if string_unary_blow_up?(receiver_value, method_name)
+          return nil if range_enumeration_blow_up?(receiver_value, method_name)
 
-          result = receiver_value.public_send(method_name)
-          foldable_constant_value?(result) ? [result] : nil
+          fold_result(receiver_value.public_send(method_name))
         rescue StandardError
           nil
         end
 
+        # `[result]` for a foldable value, `[WidenedResult]` for a number past `INTEGER_FOLD_BIT_LIMIT`, nil
+        # for anything else.
+        def fold_result(result)
+          return [WidenedResult.new(result.class.name)] if oversized_number?(result)
+
+          foldable_constant_value?(result) ? [result] : nil
+        end
+
         def unary_safe?(receiver_value, method_name)
           return true if unary_ops_for(receiver_value).include?(method_name)
 
@@ -1775,7 +1821,44 @@ module Rigor
           # with the widened class.
           return false if value.is_a?(Float) && value.nan?
           return false if value.is_a?(Complex) && complex_nan?(value)
+          return false if oversized_number?(value)
+
+          true
+        end
+
+        # True when an Integer, or an Integer part of a Rational / Complex, is past `INTEGER_FOLD_BIT_LIMIT`.
+        def oversized_number?(value)
+          case value
+          when Integer then value.bit_length > INTEGER_FOLD_BIT_LIMIT
+          when Rational then oversized_number?(value.numerator) || oversized_number?(value.denominator)
+          when Complex then oversized_number?(value.real) || oversized_number?(value.imaginary)
+          else false
+          end
+        end
+
+        # #2115 — true when `receiver_value` is a `Range` the method would walk element by element and the
+        # range holds more than `RANGE_ENUMERATION_LIMIT` elements (an endless one never stops).
+        def range_enumeration_blow_up?(receiver_value, method_name)
+          return false unless receiver_value.is_a?(Range)
+          return false if RANGE_ENDPOINT_METHODS.include?(method_name)
+          return false if RANGE_COVER_METHODS.include?(method_name) && numeric_range?(receiver_value)
+
+          !range_within_enumeration_budget?(receiver_value)
+        end
 
+        def numeric_range?(range)
+          range.begin.is_a?(Numeric) || range.end.is_a?(Numeric)
+        end
+
+        # Takes at most `RANGE_ENUMERATION_LIMIT + 1` elements (`Range#first(n)` stops there, endless or
+        # not). A range that cannot iterate at all (a Float or Time begin) raises, and so does every
+        # enumerating method on it before doing any work, so it counts as within budget: the invoke's own
+        # rescue declines an enumerating fold, and `(t0..t1).include?(t)`, which CRuby answers by `cover?`,
+        # keeps folding. A beginless range raises `RangeError` here, which the invoke's own rescue turns into
+        # a declined fold, as the enumerating method itself would raise.
+        def range_within_enumeration_budget?(range)
+          range.first(RANGE_ENUMERATION_LIMIT + 1).size <= RANGE_ENUMERATION_LIMIT
+        rescue TypeError
           true
         end
 
@@ -1796,6 +1879,58 @@ module Rigor
           true
         end
 
+        # #2115 — the result's class name when `**` / `pow` / `<<` / `>>` would produce a number past
+        # `INTEGER_FOLD_BIT_LIMIT`, read from the operands so the huge value is never computed; nil
+        # otherwise. `fold_result` applies the same bound to every other result after the fact.
+        def numeric_blow_up_class(receiver_value, method_name, arg_value)
+          return nil unless arg_value.is_a?(Integer)
+
+          case method_name
+          when :**, :pow then power_blow_up_class(receiver_value, arg_value)
+          when :<<, :>> then "Integer" if shift_blow_up?(receiver_value, method_name, arg_value)
+          end
+        end
+
+        # An Integer base to a negative power is a Rational (`2 ** -3 == (1/8)`); a Rational or Complex
+        # base keeps its class.
+        def power_blow_up_class(base, exponent)
+          return nil unless power_blow_up?(base, exponent)
+          return base.class.name unless base.is_a?(Integer)
+
+          exponent.negative? ? "Rational" : "Integer"
+        end
+
+        # A lower bound on the result's bit length is `floor(log2 |base|) * |exponent|`; past the limit the
+        # result is declined anyway. A Float base (or Float part) stays in Float arithmetic and never grows.
+        def power_blow_up?(base, exponent)
+          bits = power_base_bits(base)
+          !bits.nil? && bits * exponent.abs > INTEGER_FOLD_BIT_LIMIT
+        end
+
+        # `floor(log2 |base|)` for an Integer, the larger of its terms' for a Rational. A Complex part
+        # counts one bit more: `(1+1i) ** n` grows although neither part is past 1.
+        def power_base_bits(base)
+          case base
+          when Integer then base.abs.bit_length - 1
+          when Rational then [base.numerator.abs.bit_length, base.denominator.bit_length].max - 1
+          when Complex then complex_power_base_bits(base)
+          end
+        end
+
+        def complex_power_base_bits(base)
+          parts = [base.real, base.imaginary]
+          return nil unless parts.all? { |part| part.is_a?(Integer) || part.is_a?(Rational) }
+
+          parts.map { |part| power_base_bits(part) + 1 }.max
+        end
+
+        def shift_blow_up?(receiver_value, method_name, arg_value)
+          return false unless receiver_value.is_a?(Integer) && !receiver_value.zero?
+
+          shift = method_name == :<< ? arg_value : -arg_value
+          receiver_value.bit_length + shift > INTEGER_FOLD_BIT_LIMIT
+        end
+
         def ops_for(receiver_value)
           case receiver_value
           when Integer, Float then NUMERIC_BINARY

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

@@ -526,12 +526,60 @@ module Rigor
             registry = environment&.plugin_registry
             each_source_ancestor_candidate(scope, class_name) do |candidate|
               return nil if scope.discovered_method?(candidate, method_name, kind)
-              return candidate if ALLOWED_RBS_COMPLETE_ANCESTORS.include?(candidate) ||
-                                  registry&.rbs_complete_ancestor?(candidate)
+              next unless ALLOWED_RBS_COMPLETE_ANCESTORS.include?(candidate) ||
+                          registry&.rbs_complete_ancestor?(candidate)
+
+              return shadowed_in_ruby_order?(scope, class_name, kind, method_name, candidate) ? nil : candidate
             end
             nil
           end
 
+          # Issue #1572 — the walk above is breadth-first, so it reaches the superclass before a module an included
+          # module includes, which Ruby's order puts ahead of it (`class P < Rigor::Plugin::Base; include A` with `A`
+          # including `M` calls `M#prepare`, not `Base#prepare`), and it passes over RBS-known modules. True when the
+          # bridged `ancestor` is not what Ruby calls: on `class_name`'s {Scope::ResolutionChain} in Ruby's order, a
+          # project entry ahead of it records the name ({#project_records_name?}), an external entry ahead of it is a
+          # module RBS knows and declares the name in, or the chain does not hold it. An RBS-unknown external ahead is
+          # passed over, as the breadth-first walk always did. An unsettled chain withholds too: a mixin edge the
+          # tables cannot place (a receiver-form `Demo.include(M)` after the body, an edge in a conditional, a block or
+          # a hook) may put a definer ahead of the ancestor.
+          def shadowed_in_ruby_order?(scope, class_name, kind, method_name, ancestor)
+            chain = Scope::ResolutionChain.for(scope, class_name.to_s, kind, :methods)
+            return true if chain.unsettled?
+
+            entries = chain.entries
+            stop = entries.index do |entry|
+              entry.external? ? entry.candidates.include?(ancestor) : entry.name == ancestor
+            end
+            return true if stop.nil?
+
+            entries.first(stop).any? do |entry|
+              if entry.external?
+                rbs_declares_ahead?(scope, entry, method_name)
+              else
+                project_records_name?(scope, entry.name, method_name, entry.side)
+              end
+            end
+          end
+
+          # Whether the project entry `owner` holds the name on `kind`'s side. `discovered_methods` carries the
+          # `attr_*` and `define_method` rows project-wide, but at dispatch it has no row for a `def` in a module
+          # declared in another file, so a `def` is also asked of the project-wide def tables. ADR-46:
+          # `user_def_for` / `singleton_def_for` file the method edge, positive or negative, so a file that adds or
+          # removes the `def` on an entry ahead of the ancestor re-checks the call.
+          def project_records_name?(scope, owner, method_name, kind)
+            return true if scope.discovered_method?(owner, method_name, kind)
+
+            return !scope.singleton_def_for(owner, method_name).nil? if kind == :singleton
+
+            !scope.user_def_for(owner, method_name).nil?
+          end
+
+          def rbs_declares_ahead?(scope, entry, method_name)
+            entry.candidates.any? { |candidate| Rigor::Reflection.rbs_class_known?(candidate, scope: scope) } &&
+              !Scope::ResolutionChain::Relevance.external_lacks_on?(scope, entry.candidates, entry.side, method_name)
+          end
+
           # Issue #527 slice 1 — the RBS instance definition a Ruby-source class inherits from a CORE or
           # STDLIB ancestor, or nil. `Oj::EasyHash < Hash` answering `Dynamic[top]` to `has_key?` while
           # `{}.has_key?` folds was the largest single opacity family in the 2026-09-01 corpus sweep.

data/lib/rigor/inference/method_dispatcher.rb

@@ -220,7 +220,8 @@ module Rigor
         # `call.undefined-method`.
         patched_result =
           unless skip_project_patched
-            try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment)
+            try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment,
+                                       call_node: call_node, scope: scope)
           end
         if patched_result
           scope&.record_dynamic_origin(call_node, DynamicOrigin::EXTERNAL_GEM_WITHOUT_RBS)
@@ -258,6 +259,22 @@ module Rigor
           return discovered_result
         end
 
+        # Issue #1708 — a `pre_eval:` patch on one of the receiver's ancestors (`class Object; def zz`,
+        # `module Enumerable; def sum_by`). Below the RBS tier, whose decline means no nearer RBS declares the
+        # method, and below the tiers that answer the receiver's own patch or a gem catalogue entry. A nearer
+        # `def` in the project's source (on an RBS-known receiver, which the discovered-method tier leaves to
+        # user-method inference) stops the walk: see {#project_source_defines?}. That probe reads the scope's def
+        # index, so a single-file scope (`type-of`, `annotate`, an LSP buffer) cannot see a `def` in another file.
+        ancestor_patched =
+          if !skip_project_patched && scope
+            try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment,
+                                       call_node: call_node, scope: scope, through_ancestors: true)
+          end
+        if ancestor_patched
+          scope&.record_dynamic_origin(call_node, DynamicOrigin::EXTERNAL_GEM_WITHOUT_RBS)
+          return ancestor_patched
+        end
+
         # ADR-5 robustness — synthesized-stub-type tier. When the receiver is a type Rigor
         # invented to make an otherwise-unbuildable project signature resolve (a
         # missing-namespace module, or a stub for a referenced-but-undeclared type like an
@@ -644,7 +661,13 @@ module Rigor
       # `def to_url; "hello"; end` patched onto `String` now resolves `s.to_url` to
       # `Dynamic[Nominal[String]]` instead of the pre-3a `Dynamic[Top]`. Falls back to
       # `Dynamic[Top]` when the heuristic declined (non-literal tail expression).
-      def try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment)
+      #
+      # `through_ancestors:` (issue #1708), with a scope, searches the receiver's ancestors as well, through
+      # {ProjectPatchedMethods#lookup_through_ancestors}, stopping at a nearer project-source `def`. A private or
+      # protected patch Ruby would not let the call reach ({ProjectPatchedMethods#callable?}) answers nothing, so
+      # `1.kp` on `module Kernel; private def kp` reads as the undefined call it is.
+      def try_project_patched_method(receiver_type, method_name, arg_types, block_type, environment, # rubocop:disable Metrics/ParameterLists
+                                     call_node: nil, scope: nil, through_ancestors: false)
         registry = environment&.project_patched_methods
         return nil if registry.nil? || registry.empty?
 
@@ -652,14 +675,55 @@ module Rigor
         return nil if class_name.nil?
 
         kind = receiver_type.is_a?(Type::Singleton) ? :singleton : :instance
-        entry = registry.lookup(class_name: class_name, method_name: method_name, kind: kind)
+        entry = project_patched_entry(registry, class_name, method_name, kind, environment,
+                                      scope: scope, through_ancestors: through_ancestors)
         return nil if entry.nil?
+
+        verdict = registry.callable?(entry, explicit: explicit_non_self_receiver?(call_node),
+                                            self_type: scope ? scope.self_type : :unknown,
+                                            rbs_loader: environment.rbs_loader)
+        return nil if verdict == false
+        return Type::Combinator.untyped if verdict.nil?
         return Type::Combinator.dynamic(entry.return_type) if entry.return_type
 
         aliased = project_patched_alias_target(entry, receiver_type, arg_types, block_type, environment)
         aliased ? Type::Combinator.dynamic(aliased) : Type::Combinator.untyped
       end
 
+      def project_patched_entry(registry, class_name, method_name, kind, environment, scope:, through_ancestors:)
+        return registry.lookup(class_name: class_name, method_name: method_name, kind: kind) unless through_ancestors
+
+        registry.lookup_through_ancestors(
+          class_name: class_name, method_name: method_name, kind: kind, rbs_loader: environment.rbs_loader,
+          source_defines: ->(owner, side) { project_source_defines?(scope, owner, method_name, side) }
+        )
+      end
+
+      # Issue #1708 — does the project's own source define `method_name` on `owner` (`side` as the ancestor walk
+      # reaches it), or on a module the project prepends to or includes into it? Ruby runs that `def` ahead of a
+      # patch on a farther ancestor: `class Integer; def nn = "s"` beats `class Object; def nn = nil` in a
+      # `pre_eval:` file. The owner's level of its {Scope::ResolutionChain} (its prepends, itself, its includes
+      # and their own mixins, or a class object's singleton and its extends) holds those definers; whether one
+      # of them defines the name does not depend on their order, so the chain is searched without settling it.
+      def project_source_defines?(scope, owner, method_name, side)
+        return false unless scope.known_user_class?(owner)
+
+        chain = Scope::ResolutionChain.for(scope, owner, side, :methods)
+        own_level_end = chain.level_starts[1] || chain.entries.size
+        found = chain.search(scope, 0, own_level_end) do |entry|
+          !entry.external? && source_def?(scope, entry.name, method_name, entry.side)
+        end
+        !found.nil?
+      end
+
+      def source_def?(scope, owner, method_name, side)
+        if side == :singleton
+          scope.discovered_method?(owner, method_name, :singleton) || !scope.singleton_def_for(owner, method_name).nil?
+        else
+          scope.discovered_method?(owner, method_name, :instance) || !scope.user_def_for(owner, method_name).nil?
+        end
+      end
+
       # Issue #1702 — an alias in a `pre_eval:` patch whose old name no earlier patch binding defines
       # (`alias old_plus +` on Integer, or `alias_method :orig_succ, :succ` ahead of the patch's own `def succ`)
       # names the method the class had before the patch, so it answers what that method answers for the same