rigortype 0.1.18 → 0.1.19

data/lib/rigor/inference/macro_block_self_type.rb

@@ -17,7 +17,7 @@ module Rigor
     #   `MyApp.get(...)` call);
     # - the underlying class `X` equals or inherits from the
     #   entry's `receiver_constraint`;
-    # - the call's method name is in the entry's `verbs`.
+    # - the call's method name is in the entry's `method_names`.
     #
     # On a match the helper returns the **instance** type of
     # the receiver class (`Nominal[X]`) — the narrowed
@@ -55,7 +55,7 @@ module Rigor
         # replaces the per-call plugins × block_as_methods linear scan.
         # Entries arrive in (plugin registration, declaration) order, so
         # the first ancestry match below is the same entry the previous
-        # walk returned; the verb membership the old `matches?` checked
+        # walk returned; the method-name membership the old `matches?` checked
         # is guaranteed by the table key.
         entries = registry.contribution_index.block_entries_for(call_node.name)
         entries.each do |entry|

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # `Array#to_h { |x| [k, v] }` (and the no-block-pair tuple form's
+      # block sibling) return-type fold.
+      #
+      # `Enumerable#to_h` with a block maps every element to a
+      # `[key, value]` pair and collects them into a Hash. When the
+      # block's inferred return type is a recognizable 2-element
+      # `Tuple` (`[K, V]`), this tier projects the pair into a
+      # `Hash[K, V]` nominal whose key/value parameters are the
+      # widened pair types. Without this fold the call hits the RBS
+      # generic and the block's `[K, V]` return is dropped, typing as
+      # `Hash[Dynamic[top], Dynamic[top]]`.
+      #
+      # Value-pinned constants in the pair (`Constant[2]`) are widened
+      # to their nominal (`Integer`) for the Hash parameters: the built
+      # hash holds many keys, so pinning the parameter to a single
+      # element's literal would be unsound for the aggregate. The same
+      # widening the loop-body fixpoint applies (`Combinator#
+      # widen_value_pinned`) is reused.
+      #
+      # Declines (returns `nil`, leaving today's RBS answer) when:
+      #
+      # - there is no block at the call site,
+      # - the block return type is not a 2-element `Tuple`, or
+      # - the receiver is not an Array-shaped carrier (`Tuple` or
+      #   `Array` nominal). Hash receivers keep their existing
+      #   `ShapeDispatch#hash_to_h` identity fold.
+      module ArrayToHFolding
+        module_function
+
+        def try_dispatch(context)
+          return nil unless context.method_name == :to_h
+
+          block_type = context.block_type
+          return nil unless block_type.is_a?(Type::Tuple)
+          return nil unless block_type.elements.size == 2
+          return nil unless array_shaped?(context.receiver)
+
+          key = Type::Combinator.widen_value_pinned(block_type.elements[0])
+          value = Type::Combinator.widen_value_pinned(block_type.elements[1])
+          Type::Combinator.nominal_of("Hash", type_args: [key, value])
+        end
+
+        def array_shaped?(receiver)
+          case receiver
+          when Type::Tuple then true
+          when Type::Nominal then receiver.class_name == "Array"
+          else false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -226,13 +226,54 @@ module Rigor
           case type
           when Type::Constant then [type.value]
           when Type::Union
-            return nil unless type.members.all?(Type::Constant)
-
-            type.members.map(&:value)
+            return type.members.map(&:value) if type.members.all?(Type::Constant)
+
+            # A union that mixes `Constant<Integer>` and `IntegerRange`
+            # members (e.g. an accumulator's running fixpoint assumption
+            # `1 | int<1, 6>`) folds as the bounding interval. The
+            # range-arithmetic path (`try_fold_binary_range`) then keeps
+            # the result an `IntegerRange` instead of bailing to Dynamic.
+            union_integer_bounds(type)
           when Type::IntegerRange then type
           end
         end
 
+        # Returns the bounding `IntegerRange` over a union whose members
+        # are each an Integer `Constant` or an `IntegerRange`; `nil`
+        # otherwise (a Float constant or any non-numeric member declines,
+        # so precision is never silently lost).
+        def union_integer_bounds(union)
+          lowers = []
+          uppers = []
+          union.members.each do |member|
+            case member
+            when Type::Constant
+              return nil unless member.value.is_a?(Integer)
+
+              lowers << member.value
+              uppers << member.value
+            when Type::IntegerRange
+              lowers << member.lower
+              uppers << member.upper
+            else
+              return nil
+            end
+          end
+          # `IntegerRange#lower`/`#upper` surface an unbounded edge as
+          # `±Float::INFINITY`; `integer_range` wants the `±∞` *sentinel*,
+          # so map the extremum back.
+          Type::Combinator.integer_range(infinity_to_sentinel(lowers.min),
+                                         infinity_to_sentinel(uppers.max))
+        end
+
+        def infinity_to_sentinel(bound)
+          case bound
+          when -Float::INFINITY then Type::IntegerRange::NEG_INFINITY
+          when Float::INFINITY then Type::IntegerRange::POS_INFINITY
+          else bound
+          end
+        end
+
         def try_fold_unary(set, method_name)
           case set
           when Array              then try_fold_unary_set(set, method_name)
@@ -1265,17 +1306,16 @@ module Rigor
           end
         end
 
-        # `String#reverse` / `#swapcase` etc. produce a
-        # string the same size as the receiver; only the
-        # already-handled binary `:+` / `:*` paths can
-        # explode the output. No unary string method
-        # currently in the catalogue grows beyond the input
-        # size, so this hook is a no-op today — kept as a
-        # placeholder so future additions (e.g. `:succ` on
-        # very long strings) can be guarded without
-        # restructuring.
-        def string_unary_blow_up?(_receiver_value, _method_name)
-          false
+        # `String#reverse` / `#swapcase` / `#succ` etc. produce a string
+        # at least as large as the receiver. The binary `:+` / `:*` paths
+        # have their own `string_blow_up?` output guard; this is the unary
+        # analogue — decline to fold a unary String op whose receiver is
+        # already at or beyond `STRING_FOLD_BYTE_LIMIT`, since the folded
+        # output would be just as large and constant-materialising it buys
+        # no precision worth the bytes. Non-String receivers never blow up
+        # through a unary op, so they pass.
+        def string_unary_blow_up?(receiver_value, _method_name)
+          receiver_value.is_a?(String) && receiver_value.bytesize >= STRING_FOLD_BYTE_LIMIT
         end
 
         # Scalar / String / Symbol values fold; everything

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

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "call_context"
+require_relative "iterator_dispatch"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Symbol-form `reduce` / `inject` return-type tier.
+      #
+      # `IteratorDispatch.inject_block_params` deliberately declines the
+      # Symbol-call shapes (`(1..n).reduce(1, :*)`, `[1,2,3].reduce(:+)`)
+      # because they carry no block to bind parameters for — the decline
+      # of *block-param typing* is correct. What that decline leaves on
+      # the floor is the *return type*: with no block and no precise tier,
+      # the call falls to `Enumerable#reduce`'s RBS overload
+      # `(untyped, Symbol) -> untyped`, so the whole fold widens to
+      # `Dynamic[top]`.
+      #
+      # This tier recovers a precise return type for the Symbol-operand
+      # forms by dispatching the named operator on the accumulated type:
+      #
+      # - `(seed, :op)` (2-arg) — operand starts at the seed type `S`;
+      #   the result type is `dispatch(:op, widen(S) ∪ widen(E), widen(E))`
+      #   joined with the seed (the seed is returned unchanged when the
+      #   collection is empty). `E` is the receiver's element type.
+      # - `(:op)` (1-arg) — no seed: the first element seeds the memo, so
+      #   the operand type is `E` and the result is
+      #   `dispatch(:op, widen(E), widen(E))`. RBS models this overload as
+      #   `() { (E, E) -> E } -> E` (no nil), so the tier returns the
+      #   operator result without manufacturing a nil — staying consistent
+      #   with the declared type and Rigor's false-positive discipline
+      #   (the empty-collection `nil` runtime case is not modelled by RBS
+      #   and adding it here would only pressure callers into defensive
+      #   nil-handling for code that works).
+      #
+      # The tier is precision-additive: it declines (returns nil, today's
+      # `Dynamic[top]` behaviour) for every shape it cannot prove —
+      # unknown element type, Dynamic / Top receiver, a non-`Constant`
+      # Symbol operand, or an operator the engine cannot dispatch on the
+      # widened operand types.
+      #
+      # `widen_value_pinned` (ADR-55/56) collapses `Constant`/`IntegerRange`
+      # operands to their nominal base before dispatch so the result is the
+      # operator's nominal return (`Integer`) rather than a constant-folded
+      # `Constant[120]` — full constant folding of the reduction is out of
+      # scope, the precision target is the carrier (`Integer`), not the value.
+      module ReduceFolding
+        module_function
+
+        REDUCE_METHODS = %i[reduce inject].freeze
+        private_constant :REDUCE_METHODS
+
+        # Allow-listed pure, side-effect-free fold operators. Each is
+        # safe on the foldable constant operand classes (Integer / Float
+        # / Rational); division / modulo by zero is caught by the rescue
+        # harness in `execute_constant_reduce` and declines to the
+        # nominal fold. `:gcd` / `:lcm` are valid binary Integer methods
+        # (`acc.public_send(:gcd, elem)`); `:min` / `:max` are *not* (no
+        # `Integer#min`/`#max` — they would raise and decline), so they
+        # are deliberately omitted.
+        CONSTANT_FOLD_OPERATORS = %i[+ * - / % & | ^ gcd lcm].freeze
+        private_constant :CONSTANT_FOLD_OPERATORS
+
+        # Hard caps (ADR-41 WD4 style). The element count is checked
+        # BEFORE the receiver is enumerated, so a `(1..1_000_000)` range
+        # never materialises. The bit-length cap rejects factorial-style
+        # blow-up (`(1..64).reduce(:*)` is a ~296-bit Integer) so the
+        # folded value can never become an analyzer-heavy bignum.
+        CONSTANT_FOLD_ELEMENT_CAP = 64
+        CONSTANT_FOLD_BIT_CAP = 256
+        private_constant :CONSTANT_FOLD_ELEMENT_CAP, :CONSTANT_FOLD_BIT_CAP
+
+        # @return [Rigor::Type, nil]
+        def try_dispatch(context)
+          return nil unless REDUCE_METHODS.include?(context.method_name)
+          return nil if context.block_type
+
+          args = context.args
+          operator, seed = operator_and_seed(args)
+          return nil if operator.nil?
+
+          # Precision pre-check: when the receiver is a fully-constant
+          # collection (a `Constant[Range]` with foldable endpoints or a
+          # `Tuple` of `Constant` elements) and the operator is an
+          # allow-listed pure op, treat the reduction as a pure function
+          # and execute it on the real values, capped. Any decline (size
+          # cap, non-constant member, magnitude, exception) falls through
+          # to the carrier-precise nominal fold below — byte-identical to
+          # pre-fold behaviour.
+          folded = try_constant_reduce(context.receiver, operator, seed)
+          return folded if folded
+
+          element = IteratorDispatch.element_type_of(context.receiver)
+          return nil if element.nil?
+
+          fold_result(operator, seed, element, context.environment)
+        end
+
+        # Executes the reduction on real constant values, or returns nil
+        # to decline. The caller falls through to the nominal fold on a
+        # nil return, so every guard here is precision-additive only.
+        #
+        # @param seed [Rigor::Type, nil] the optional seed type; only a
+        #   foldable `Constant` seed is honoured, any other seed declines.
+        # @return [Rigor::Type::Constant, nil]
+        def try_constant_reduce(receiver, operator, seed)
+          return nil unless CONSTANT_FOLD_OPERATORS.include?(operator)
+
+          members = constant_members(receiver)
+          return nil if members.nil?
+
+          seed_value, seed_present = constant_seed(seed)
+          return nil if !seed.nil? && !seed_present
+
+          execute_constant_reduce(members, operator, seed_value, seed_present)
+        end
+
+        # Extracts the receiver's elements as a Ruby Array of foldable
+        # constant values, or nil to decline. Checks the size cap BEFORE
+        # enumerating so an unbounded / huge `Constant[Range]` (e.g.
+        # `(1..1_000_000)`) never calls `to_a`.
+        #
+        # @return [Array, nil]
+        def constant_members(receiver)
+          case receiver
+          when Type::Constant
+            constant_range_members(receiver.value)
+          when Type::Tuple
+            tuple_members(receiver.elements)
+          end
+        end
+
+        def constant_range_members(value)
+          return nil unless value.is_a?(Range)
+
+          first = value.begin
+          last = value.end
+          return nil unless foldable?(first) && foldable?(last)
+          # Reject endless / beginless ranges (`(1..)`, `(..5)`).
+          return nil if first.nil? || last.nil?
+
+          # Size BEFORE enumeration — `Range#size` is O(1) for numeric
+          # ranges and never materialises the elements.
+          size = value.size
+          return nil unless size.is_a?(Integer)
+          return nil if size > CONSTANT_FOLD_ELEMENT_CAP
+
+          value.to_a
+        rescue StandardError
+          nil
+        end
+
+        def tuple_members(elements)
+          return nil if elements.size > CONSTANT_FOLD_ELEMENT_CAP
+          return nil unless elements.all? { |e| e.is_a?(Type::Constant) && foldable?(e.value) }
+
+          elements.map(&:value)
+        end
+
+        # @return [Array(Object, Boolean)] `[seed_value, present?]`. A nil
+        #   seed type yields `[nil, false]` (no-seed form). A foldable
+        #   `Constant` seed yields `[value, true]`. Any other seed yields
+        #   `[nil, false]` so the caller can decline.
+        def constant_seed(seed)
+          return [nil, false] if seed.nil?
+          return [nil, false] unless seed.is_a?(Type::Constant) && foldable?(seed.value)
+
+          [seed.value, true]
+        end
+
+        # Runs the actual reduction, guarded by the rescue harness and
+        # the magnitude cap. Empty-collection semantics match Ruby:
+        # `[].reduce(s, :op) == s` (seed form) and `[].reduce(:op) == nil`
+        # (no-seed form → declines so the nominal fold's no-nil contract
+        # stands; see `fold_result`).
+        #
+        # @return [Rigor::Type::Constant, nil]
+        def execute_constant_reduce(members, operator, seed_value, seed_present)
+          result =
+            if seed_present
+              members.reduce(seed_value) { |acc, e| acc.public_send(operator, e) }
+            else
+              # No-seed empty collection reduces to nil; decline so the
+              # nominal no-nil contract is preserved rather than folding
+              # to `Constant[nil]`.
+              return nil if members.empty?
+
+              members.reduce { |acc, e| acc.public_send(operator, e) }
+            end
+
+          return nil unless foldable?(result)
+          return nil if magnitude_too_large?(result)
+
+          Type::Combinator.constant_of(result)
+        rescue StandardError
+          # Division by zero, type mismatch, or any operator error: decline.
+          nil
+        end
+
+        FOLDABLE_FOLD_CLASSES = [Integer, Float, Rational].freeze
+        private_constant :FOLDABLE_FOLD_CLASSES
+
+        def foldable?(value)
+          FOLDABLE_FOLD_CLASSES.any? { |klass| value.is_a?(klass) }
+        end
+
+        # Rejects bignum blow-up. A folded Integer wider than the bit cap
+        # (factorial, repeated multiplication) declines to the nominal
+        # `Integer` carrier rather than parking a heavy literal in the
+        # type graph. Float / Rational carry no comparable blow-up risk.
+        def magnitude_too_large?(result)
+          result.is_a?(Integer) && result.bit_length > CONSTANT_FOLD_BIT_CAP
+        end
+
+        # Splits the call's positional arguments into the operator Symbol
+        # and the optional seed. Returns `[nil, nil]` for any non-Symbol-
+        # operand shape so `try_dispatch` declines.
+        #
+        # - `[:op]`          -> operator `:op`, no seed
+        # - `[seed, :op]`    -> operator `:op`, seed `seed`
+        def operator_and_seed(args)
+          case args.size
+          when 1
+            sym = symbol_value(args[0])
+            sym ? [sym, nil] : [nil, nil]
+          when 2
+            sym = symbol_value(args[1])
+            sym ? [sym, args[0]] : [nil, nil]
+          else
+            [nil, nil]
+          end
+        end
+
+        def symbol_value(type)
+          return nil unless type.is_a?(Type::Constant)
+
+          type.value.is_a?(Symbol) ? type.value : nil
+        end
+
+        # Dispatches the operator on the widened operand types. With a
+        # seed the memo type spans `seed | element` (the first iteration's
+        # memo is the seed, every later iteration's memo is a previous
+        # operator result); without a seed the memo and operand are both
+        # the element type.
+        def fold_result(operator, seed, element, environment)
+          widened_element = Type::Combinator.widen_value_pinned(element)
+          memo = if seed.nil?
+                   widened_element
+                 else
+                   Type::Combinator.union(
+                     Type::Combinator.widen_value_pinned(seed), widened_element
+                   )
+                 end
+
+          result = dispatch_operator(memo, operator, widened_element, environment)
+          return nil if result.nil?
+
+          # The seed itself is the result when the collection is empty
+          # (`[].reduce(s, :op) == s`), so a 2-arg fold's static type is
+          # the operator result joined with the seed. The seed is widened
+          # (`Constant[0]` -> `Integer`) for the join so the carrier stays
+          # the precision target rather than leaking a value-pinned member
+          # (`0 | Integer`) — full constant folding of the fold is out of
+          # scope.
+          return result if seed.nil?
+
+          Type::Combinator.union(Type::Combinator.widen_value_pinned(seed), result)
+        end
+
+        def dispatch_operator(memo, operator, operand, environment)
+          MethodDispatcher.dispatch(
+            receiver_type: memo, method_name: operator,
+            arg_types: [operand], environment: environment
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -38,10 +38,81 @@ module Rigor
           return nil unless SingletonFolding.receiver?(receiver, "Regexp")
           return fold_escape(args) if REGEXP_ESCAPE_METHODS.include?(method_name)
           return fold_new(args) if method_name == :new
+          return fold_last_match(context) if method_name == :last_match
 
           nil
         end
 
+        # `Regexp.last_match` reads the same match-data slot the perlish
+        # `$~` global tracks. On a proven-match edge — the truthy branch
+        # of `if str =~ /re/`, the surviving path of `unless /re/ =~ s;
+        # raise; end`, a `case`/`when` regex arm — the flow engine has
+        # already narrowed `$~` to a non-nil `MatchData` (see
+        # `Narrowing#regex_match_predicate_scopes`). Upstream RBS types
+        # `Regexp.last_match` as `() -> MatchData?` / `(int) -> String?`,
+        # so without this consult the call drops back to the nilable
+        # return even where the surrounding flow has *proven* the match
+        # succeeded — re-introducing the `possible nil receiver` the `$~`
+        # narrowing exists to remove the moment the code reaches for the
+        # match through the method rather than the global.
+        #
+        # Mirrors the global's narrowing exactly, so it rides the same
+        # `Scope#forget_match_globals` invalidation (an intervening call
+        # that can re-run a match clears `$~`, and this consult clears
+        # with it):
+        #
+        # * 0-arg  -> `MatchData` (the narrowed `$~`)
+        # * `(N)`  -> `String` when capture group N is unconditional on
+        #             every successful match (the same set the `$N`
+        #             globals narrow), else `String?` (an optional /
+        #             alternation-reachable group is nil at runtime even
+        #             on a successful match).
+        # * `(:name)` / `(0)` and other forms defer to RBS.
+        #
+        # Declines (returns nil -> RBS) whenever `$~` is NOT proven
+        # non-nil: no match edge established it, or a falsey edge bound it
+        # to `Constant[nil]`. Narrowing only on the proven edge keeps the
+        # bare `m = Regexp.last_match; m[...]` (no preceding match) firing
+        # exactly as today — this never invents a match.
+        def fold_last_match(context)
+          scope = context.scope
+          return nil if scope.nil?
+
+          match_data = scope.global(:$~)
+          return nil unless proven_match?(match_data)
+
+          args = context.args
+          return Type::Combinator.nominal_of("MatchData") if args.empty?
+          return nil unless args.size == 1
+
+          fold_last_match_group(args.first, scope)
+        end
+
+        # Narrowed `$~` is a non-nil `Nominal[MatchData]`. A bare
+        # `MatchData?` / `nil` / Dynamic binding is NOT a proven match.
+        def proven_match?(match_data)
+          match_data.is_a?(Type::Nominal) && match_data.class_name == "MatchData"
+        end
+
+        # `Regexp.last_match(N)` for a value-pinned positive Integer N.
+        # Track the matching `$N` global the predicate edge already
+        # narrowed: present (`String`) means the group is unconditional,
+        # absent means it is optional / alternation-reachable (nil at
+        # runtime on a success), so we surface `String?`. A non-constant
+        # or non-positive index defers to RBS.
+        def fold_last_match_group(arg, scope)
+          return nil unless arg.is_a?(Type::Constant)
+
+          index = arg.value
+          return nil unless index.is_a?(Integer) && index.positive?
+
+          string_t = Type::Combinator.nominal_of("String")
+          group_global = scope.global(:"$#{index}")
+          return string_t if group_global.is_a?(Type::Nominal) && group_global.class_name == "String"
+
+          Type::Combinator.union(string_t, Type::Combinator.constant_of(nil))
+        end
+
         # `Regexp.escape(str)` / `.quote(str)` — one String arg.
         def fold_escape(args)
           return nil unless args.size == 1