rigortype 0.1.19 → 0.2.0

data/lib/rigor/inference/builtins/enumerable_catalog.rb

@@ -11,8 +11,8 @@ module Rigor
       # catalog is NOT routed through
       # `MethodDispatcher::ConstantFolding::CATALOG_BY_CLASS`
       # (which dispatches on the receiver's concrete class).
-      # The data is consumed by future include-aware lookup —
-      # see `docs/CURRENT_WORK.md` for the planned slice.
+      # The data is wired into `MODULE_CATALOGS` in
+      # `MethodDispatcher::ConstantFolding` (ancestor-chain lookup).
       ENUMERABLE_CATALOG = MethodCatalog.for_topic(
         "enumerable",
         mutating_selectors: {

data/lib/rigor/inference/builtins/method_catalog.rb

@@ -27,6 +27,24 @@ module Rigor
         FOLDABLE_PURITIES = Set["leaf", "trivial", "leaf_when_numeric"].freeze
         EMPTY_CATALOG = { "classes" => {} }.freeze
 
+        # Selectors that are classified `:leaf` by the C-body analysis
+        # (they read no global mutable state in the C sense) but whose
+        # result is NOT reproducible across Ruby processes, so they must
+        # never be folded into a `Constant`:
+        #
+        # - `hash` — every core `#hash` (`String`/`Symbol`/`Integer`/
+        #   `Float`/…) is salted with a per-process SipHash seed, so
+        #   `"x".hash` differs in every process. Folding bakes one
+        #   process's value into the type and the on-disk cache.
+        # - `object_id` / `__id__` — identity-allocated per process.
+        #
+        # This is a UNIVERSAL block (across every catalogued class)
+        # because `hash` / `object_id` are `Object`-level and present on
+        # every receiver; a per-class blocklist would silently miss a
+        # class. The deterministic siblings (`inspect`, `to_s`) are
+        # unaffected.
+        NON_REPRODUCIBLE_SELECTORS = Set[:hash, :object_id, :__id__].freeze
+
         # Shared root for the offline-generated catalogues. Resolving it
         # here keeps the repo-relative `../../../../` hop in one place
         # instead of copying it into every per-topic loader.
@@ -59,6 +77,7 @@ module Rigor
 
         def safe_for_folding?(class_name, selector, kind: :instance)
           class_name_str = class_name.to_s
+          return false if NON_REPRODUCIBLE_SELECTORS.include?(selector.to_sym)
           return false if blocked?(class_name_str, selector)
 
           entry = method_entry(class_name_str, selector, kind: kind)

data/lib/rigor/inference/builtins/string_catalog.rb

@@ -22,7 +22,15 @@ module Rigor
             :replace, :initialize, :initialize_copy, :clear, :<<, :concat, :insert,
             :prepend, :force_encoding, :encode, :scrub, :unicode_normalize, :"[]=",
             :upto, :each_byte, :each_char, :each_codepoint,
-            :each_grapheme_cluster, :each_line, :bytesplice
+            :each_grapheme_cluster, :each_line, :bytesplice,
+            # `crypt` is not a mutator but is blocked from folding for the
+            # same "do not bake a non-pure result into a Constant" reason:
+            # `rb_str_crypt` delegates to the platform `crypt(3)`, whose
+            # output (algorithm and digest) varies by libc / OS, so
+            # `"x".crypt("ab")` is not deterministic across the platforms
+            # an analyzed project may target. The catalog classifies it
+            # `:leaf` from its C body; this entry overrides that.
+            :crypt
           ],
           "Symbol" => Set[
             # Symbol is immutable in Ruby; the classifier mis-flags

data/lib/rigor/inference/expression_typer.rb

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "../type"
 require_relative "../ast"
+require_relative "../source/constant_path"
 require_relative "../analysis/self_call_resolution_recorder"
 require_relative "block_parameter_binder"
 require_relative "body_fixpoint"
@@ -14,6 +15,7 @@ require_relative "indexed_narrowing"
 require_relative "macro_block_self_type"
 require_relative "method_dispatcher"
 require_relative "narrowing"
+require_relative "struct_fold_safety"
 
 module Rigor
   module Inference
@@ -323,12 +325,7 @@ module Rigor
         dynamic_top
       end
 
-      # Recognised value-bearing position the Slice 2 engine does not yet
-      # narrow: self, instance/class/global variable reads, block bodies.
-      # Slice 3+ refines these in place; for now we acknowledge the node
-      # class so the coverage scanner stops flagging it without recording
-      # a fail-soft event for every occurrence.
-      # Slice A-engine. `Prism::SelfNode` resolves to the scope's
+      # `Prism::SelfNode` resolves to the scope's
       # `self_type` when one has been injected (by
       # `StatementEvaluator` at class-body and method-body
       # boundaries) or `Dynamic[Top]` at the top level. Class-body
@@ -412,7 +409,7 @@ module Rigor
       end
 
       def type_of_constant_path(node)
-        full_name = build_constant_path_name(node)
+        full_name = Source::ConstantPath.qualified_name_or_nil(node)
         return fallback_for(node, family: :prism) if full_name.nil?
 
         resolve_constant_name(full_name) || fallback_for(node, family: :prism)
@@ -481,24 +478,6 @@ module Rigor
         end
       end
 
-      # Builds the dotted-colon name for a `Foo`, `Foo::Bar`, or `::Foo`
-      # path. Returns nil when an inner segment is not itself a constant
-      # reference (for example `expr::Foo`), so the caller can fall back.
-      def build_constant_path_name(node)
-        case node
-        when Prism::ConstantReadNode
-          node.name.to_s
-        when Prism::ConstantPathNode
-          parent = node.parent
-          return node.name.to_s if parent.nil?
-
-          parent_name = build_constant_path_name(parent)
-          return nil if parent_name.nil?
-
-          "#{parent_name}::#{node.name}"
-        end
-      end
-
       # Slice 5 phase 1 upgrades hash literals to `HashShape{...}`
       # when every entry is a static `AssocNode` whose key is a
       # `SymbolNode` or `StringNode` with a known value (covering the
@@ -837,7 +816,7 @@ module Rigor
       # Other pattern shapes (Range, Regexp, custom `===`) stay
       # `:maybe` — the existing union fallback handles them.
       def case_when_pattern_certainty(subject_type, pattern_node)
-        class_name = build_constant_path_name(pattern_node)
+        class_name = Source::ConstantPath.qualified_name_or_nil(pattern_node)
         return Narrowing.class_pattern_certainty(subject_type, class_name, environment: scope.environment) if class_name
 
         literal = literal_pattern_value(pattern_node)
@@ -925,7 +904,8 @@ module Rigor
       end
 
       # `while` and `until` loops produce nil unless interrupted by
-      # `break VALUE`, which Slice 3 phase 1 does not yet model.
+      # `break VALUE`; the expression value of `break VALUE` is not yet
+      # modeled (scope break-path propagation landed in `eval_loop`).
       # Returning Constant[nil] is safe and matches Ruby semantics for
       # the common case.
       def type_of_loop(_node)
@@ -2382,7 +2362,19 @@ module Rigor
           environment: scope.environment,
           locals: locals.freeze,
           self_type: receiver,
-          discovery: scope.discovery
+          discovery: scope.discovery,
+          struct_fold_safe_locals: struct_fold_safe_locals_for(def_node.body)
+        )
+      end
+
+      # ADR-48 Struct slice 3 — the fold-safe-local set for a method body
+      # (runs only on a return-memo miss, so the per-call cost is bounded —
+      # measured perf-neutral). Struct member layouts of constant receivers
+      # are resolved through the discovery side-table the body scope inherits.
+      def struct_fold_safe_locals_for(body)
+        StructFoldSafety.fold_safe_locals(
+          body,
+          ->(name) { scope.struct_member_layout(name)&.[](:members) }
         )
       end
 

data/lib/rigor/inference/hkt_body.rb

@@ -7,18 +7,15 @@ module Rigor
     # piece of a Rigor-side type expression that the reducer
     # ({HktReducer}) walks against a concrete argument list.
     #
-    # Slice 2a ships a programmatic constructor surface only:
-    # plugin and Rigor-bundled overlay authors build a body
-    # tree by hand using these node types. The string-grammar
-    # parser that reads `Definition#body` (the raw String slot
-    # already populated by Slice 1's `HktDirectives.parse_define`)
-    # into a tree is Slice 2b's deliverable; until it ships, the
-    # `body` String stays opaque and `body_tree` is the
-    # evaluable form.
+    # Slice 2a ships a programmatic constructor surface; plugin
+    # and Rigor-bundled overlay authors may build a body tree
+    # by hand using these node types. The string-grammar parser
+    # (`HktBodyParser`, Slice 2b, shipped) reads `Definition#body`
+    # (populated by Slice 1's `HktDirectives.parse_define`) into
+    # this node tree; `body_tree` is the evaluable form.
     #
-    # The five node types cover the JSON.parse and dry-monads
-    # use cases ADR-20 § Implementation slicing names as
-    # near-term adopters:
+    # The nine node types cover JSON.parse, dry-monads, and the
+    # ADR-20 § D3 conditional / membership forms (shipped):
     #
     # - {TypeLeaf}    — wraps a fully-built `Rigor::Type`
     #   (use for atoms like `nil`, `Constant<true>`,

data/lib/rigor/inference/hkt_body_parser.rb

@@ -11,29 +11,27 @@ module Rigor
     # `%a{rigor:v1:hkt_define}` payloads) into the `HktBody`
     # node tree the Slice 2a reducer evaluates against.
     #
-    # The minimum-viable grammar covered here is the
-    # union-of-atoms-and-parameterised-forms subset of ADR-20
-    # § D3 — sufficient for `JSON.parse`'s `json::value`
-    # recursive sum and for any other recursive-data-shape
-    # signatures (Lisp value trees, dry-types refinements
-    # without conditionals). The conditional / indexed-access
-    # forms (`E <: T ? A : B`, `E in [k1, k2]`) drafted in D3
-    # remain a follow-up slice — bodies that contain `?`
-    # raise `ParseError` and the calling directive parser
-    # drops the body_tree (the body String remains stored and
-    # the reducer falls back to `app.bound`).
+    # The grammar implements the full ADR-20 § D3 subset:
+    # union-of-atoms/parameterised-forms for `JSON.parse`'s
+    # `json::value` recursive sum, plus the conditional and
+    # membership forms shipped in subsequent slices. Indexed-access
+    # forms remain deferred (no concrete demand yet).
     #
-    # ## Grammar (slice 2b)
+    # ## Grammar
     #
     #     body         := union
     #     union        := type_expr ("|" type_expr)*
     #     type_expr    := atom | nominal_app | app_ref | param
+    #                   | conditional
     #     atom         := "nil" | "true" | "false" | "bool" | "untyped"
     #     param        := UCNAME   (when UCNAME ∈ params)
     #     nominal_app  := class_name ("[" type_expr ("," type_expr)* "]")?
     #     class_name   := "::"? UCNAME ("::" UCNAME)*
     #     app_ref      := "App" "[" uri "," type_expr ("," type_expr)* "]"
     #     uri          := IDENT ("::" IDENT)+
+    #     conditional  := "(" test "?" union ":" union ")"
+    #     test         := type_expr ("<:" | "==") type_expr
+    #                   | type_expr "in" "[" type_expr ("," type_expr)* "]"
     #     UCNAME       := /[A-Z]\w*/
     #     IDENT        := /[a-z_]\w*/
     #

data/lib/rigor/inference/hkt_registry.rb

@@ -10,12 +10,12 @@ module Rigor
     # `%a{rigor:v1:hkt_define: ...}` annotations in shipped
     # `.rbs` files.
     #
-    # Slice 1 keeps the registry **opaque**: it stores the
-    # registration metadata (arity, variance, bound) and the
-    # un-evaluated definition body (a raw String — Slice 2
-    # introduces the conditional / indexed-access evaluator that
-    # parses the body and reduces `Type::App` instances against
-    # it). The carrier never needs to read from the registry
+    # The registry stores registration metadata (arity, variance,
+    # bound) and the definition body as both a raw String and an
+    # evaluable `HktBody` node tree. `HktReducer` (Slice 2a) and
+    # `HktBodyParser` (Slice 2b) are both shipped and reduce
+    # `Type::App` instances against the definition. The carrier
+    # never needs to read from the registry
     # because Slice 1's `Type::App` carries its `bound` directly;
     # the registry exists at this slice solely so the parser
     # round-trip and downstream slices have a stable target API.
@@ -65,16 +65,15 @@ module Rigor
       # definition.
       #
       # `body` is the raw String payload from the `%a{...}`
-      # annotation (Slice 1's parser populates it). It stays
-      # opaque until Slice 2b's body-string parser lands.
+      # annotation (Slice 1's parser populates it); parsed into
+      # `body_tree` by `HktBodyParser` (Slice 2b, shipped).
       #
-      # `body_tree` is the optional evaluable form: a
+      # `body_tree` is the evaluable form: a
       # `Rigor::Inference::HktBody::*` node tree the Slice 2a
       # reducer walks against the application's concrete
       # arguments. Plugin and Rigor-bundled overlay authors
       # construct it programmatically through
-      # {with_body_tree}; the Slice 2b string parser will set
-      # it from `body` once it ships. The reducer treats a
+      # {.definition_with_body_tree}. The reducer treats a
       # `nil` `body_tree` as "definition not yet evaluable"
       # and returns the registered bound.
       Definition = Data.define(:uri, :params, :body, :body_tree, :source_path, :source_line) do

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

@@ -42,10 +42,7 @@ module Rigor
         #
         # This is the single place the call-context field list is
         # enumerated — the whole point of the value object is to absorb
-        # the wide keyword list the tiers used to each redeclare. The
-        # ParameterLists disable here retires the per-tier disables (the
-        # `RbsDispatch` quartet-plus signatures) rather than adding to
-        # them.
+        # the wide keyword list the tiers used to each redeclare.
         def self.build(receiver:, method_name:, args:, # rubocop:disable Metrics/ParameterLists
                        block_type: nil, environment: nil, call_node: nil,
                        scope: nil, self_type_override: nil, public_only: false)

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

@@ -40,7 +40,7 @@ module Rigor
       #   receiver/argument combination.
       #
       # Anything else returns `nil`, signalling "no rule matched" so the
-      # caller (`ExpressionTyper`) falls back to `Dynamic[Top]` and records a
+      # caller (`MethodDispatcher`) falls back to `Dynamic[Top]` and records a
       # fail-soft event. Slice 4 (RBS-backed) layers another dispatch tier
       # behind this rule book, but the constant-folding semantics defined
       # here MUST NOT regress: any value reachable by literal arithmetic at
@@ -51,7 +51,7 @@ module Rigor
         NUMERIC_BINARY = Set[
           :+, :-, :*, :/, :%, :**, :&, :|, :^, :<<, :>>,
           :<, :<=, :>, :>=, :==, :!=, :<=>,
-          :gcd, :lcm, :fdiv
+          :gcd, :lcm, :fdiv, :quo, :ceildiv, :[]
         ].freeze
         STRING_BINARY  = Set[
           :+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>,
@@ -60,12 +60,31 @@ module Rigor
           :match?, :index, :rindex, :center, :ljust, :rjust,
           # 1-arg pure transforms/queries whose output never exceeds the
           # input: `delete`/`squeeze` shrink the string, `count` → Integer.
-          :delete, :count, :squeeze
+          :delete, :count, :squeeze,
+          # ASCII / Unicode-case-fold comparison — deterministic, no
+          # locale read: `casecmp` → -1/0/1, `casecmp?` → bool/nil.
+          :casecmp, :casecmp?
         ].freeze
         SYMBOL_BINARY  = Set[:==, :!=, :<=>, :<, :<=, :>, :>=].freeze
         BOOL_BINARY    = Set[:&, :|, :^, :==, :!=, :===].freeze
         NIL_BINARY     = Set[:==, :!=].freeze
-        RATIONAL_BINARY = Set[:div, :modulo, :%, :remainder, :fdiv].freeze
+        # Rational arithmetic / ordering are exact and pure. Division
+        # (`/`) and `**` may return a `Float`/`Complex` for some operands,
+        # all of which are foldable `Constant` value classes. `==` / `!=`
+        # are deliberately EXCLUDED: `Rational#==` (`nurat_eqeq_p`) routes
+        # through `rb_funcall(:==)` on the operands — user-redefinable —
+        # so the catalog classifies it `:dispatch` and the equality stays
+        # the RBS `bool`. (The set would otherwise bypass that gate.)
+        RATIONAL_BINARY = Set[
+          :+, :-, :*, :/, :**, :<=>, :<, :<=, :>, :>=,
+          :div, :modulo, :%, :remainder, :fdiv, :quo
+        ].freeze
+        # Complex arithmetic. `ops_for` gains a `Complex` branch so these
+        # reach the binary fold path (Complex was previously unary-only).
+        # `/` and `**` stay foldable (Complex result). `==` / `!=` are
+        # excluded for the same reason as Rational (`nucomp_eqeq_p`
+        # delegates to operand `==`); ordering is undefined for Complex.
+        COMPLEX_BINARY = Set[:+, :-, :*, :/, :**].freeze
 
         # v0.0.3 C — pure unary catalogue. Each method must:
         # - take zero arguments,
@@ -83,20 +102,30 @@ module Rigor
         # user-defined `def is_odd(n) = n.odd?` so
         # `Parity.new.is_odd(3)` types as `Constant[true]`
         # rather than the RBS-widened `bool`.
+        # NOTE: `:hash` is deliberately NOT in any of these sets.
+        # `Object#hash` (and the `String`/`Symbol`/`Integer`/`Float`
+        # overrides) is salted with a per-process SipHash seed, so
+        # `"abc".hash` returns a different Integer in every Ruby
+        # process. Folding it to a `Constant` would bake one process's
+        # value into the type (and the on-disk cache), making the
+        # result non-deterministic across runs — a violation of the
+        # purity contract this catalogue rests on. A literal's `.hash`
+        # therefore stays the RBS-widened `Integer`. The deterministic
+        # siblings `:inspect` / `:to_s` remain folded.
         INTEGER_UNARY = Set[
           :odd?, :even?, :zero?, :positive?, :negative?,
           :succ, :pred, :next, :abs, :magnitude,
           :bit_length, :to_s, :to_i, :to_int, :to_f,
           :floor, :ceil, :round, :truncate, :chr,
-          :inspect, :hash, :-@, :+@, :~
+          :inspect, :-@, :+@, :~, :to_r, :to_c
         ].freeze
         FLOAT_UNARY = Set[
           :zero?, :positive?, :negative?,
           :nan?, :finite?, :infinite?,
           :abs, :magnitude, :floor, :ceil, :round, :truncate,
           :next_float, :prev_float,
-          :to_s, :to_i, :to_int, :to_f,
-          :inspect, :hash, :-@, :+@
+          :to_s, :to_i, :to_int, :to_f, :to_r, :rationalize,
+          :inspect, :-@, :+@
         ].freeze
         STRING_UNARY = Set[
           :upcase, :downcase, :capitalize, :swapcase,
@@ -104,20 +133,29 @@ module Rigor
           :empty?, :strip, :lstrip, :rstrip, :chomp, :chop, :squeeze,
           :to_s, :to_str, :to_sym, :intern,
           :to_i, :to_f, :ord, :chr, :hex, :oct, :succ, :next,
-          :inspect, :hash
+          :sum, :inspect
         ].freeze
         SYMBOL_UNARY = Set[
           :to_s, :to_sym, :to_proc, :length, :size,
           :empty?, :upcase, :downcase, :capitalize,
-          :swapcase, :inspect, :hash
+          :swapcase, :succ, :next, :inspect
         ].freeze
-        BOOL_UNARY = Set[:!, :to_s, :inspect, :hash, :&, :|, :^].freeze
-        NIL_UNARY  = Set[:nil?, :!, :to_s, :to_a, :to_h, :inspect, :hash].freeze
+        BOOL_UNARY = Set[:!, :to_s, :inspect, :&, :|, :^].freeze
+        NIL_UNARY  = Set[:nil?, :!, :to_s, :to_a, :to_h, :inspect].freeze
         RATIONAL_UNARY = Set[
           :zero?, :integer?, :real, :abs2,
-          :conj, :conjugate, :nonzero?
+          :conj, :conjugate, :nonzero?,
+          :numerator, :denominator, :abs, :magnitude,
+          :to_f, :to_i, :to_int, :to_r, :rationalize,
+          :floor, :ceil, :round, :truncate,
+          :-@, :+@
+        ].freeze
+        COMPLEX_UNARY = Set[
+          :zero?, :nonzero?,
+          :abs, :magnitude, :abs2, :arg, :angle, :phase,
+          :conjugate, :conj, :real, :imaginary, :imag,
+          :to_c, :-@, :+@
         ].freeze
-        COMPLEX_UNARY = Set[:zero?, :nonzero?].freeze
 
         STRING_FOLD_BYTE_LIMIT = 4096
 
@@ -386,9 +424,15 @@ module Rigor
         # Only fires on a single-receiver Range with finite integer
         # endpoints; mixed unions fall through so the existing
         # union-of-Constants path keeps the rest of the arms.
-        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length, :entries, :minmax].freeze
+        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length, :entries, :minmax,
+                                 :sum].freeze
+        # 1-arg head/tail projections on a `Constant<Range>`. `first(n)` /
+        # `take(n)` return the first `n` elements, `last(n)` the final `n` —
+        # each lifts to a per-position `Tuple[Constant[Integer]…]`. The
+        # no-arg `first` / `last` stay on the unary path (single Integer).
+        RANGE_FOLD_BINARY_METHODS = Set[:first, :last, :take].freeze
         RANGE_TO_A_LIMIT = 16
-        private_constant :RANGE_FOLD_METHODS, :RANGE_TO_A_LIMIT
+        private_constant :RANGE_FOLD_METHODS, :RANGE_FOLD_BINARY_METHODS, :RANGE_TO_A_LIMIT
 
         def try_fold_range_constant_unary(receiver_values, method_name)
           return nil unless RANGE_FOLD_METHODS.include?(method_name)
@@ -408,6 +452,11 @@ module Rigor
           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)
+          # `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)
           end
         end
 
@@ -441,10 +490,46 @@ module Rigor
           )
         end
 
+        # `(1..10).first(3)` / `.take(3)` / `.last(3)` — the 1-arg head /
+        # tail forms. `first`/`last` already fold no-arg through the unary
+        # path; this is the n-arg sibling, mirroring the Tuple carrier's
+        # `first(n)`/`take(n)` handlers. Lifts to `Tuple[Constant…]`.
+        def try_fold_range_constant_binary(receiver_values, method_name, arg_values)
+          return nil unless RANGE_FOLD_BINARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1 && arg_values.size == 1
+
+          range = receiver_values.first
+          return nil unless range.is_a?(Range)
+          return nil unless range.begin.is_a?(Integer) && range.end.is_a?(Integer)
+
+          range_take_tuple(range, method_name, arg_values.first)
+        rescue StandardError
+          nil
+        end
+
+        def range_take_tuple(range, method_name, count)
+          return nil unless count.is_a?(Integer) && !count.negative?
+          # `first(n)`/`last(n)`/`take(n)` materialise at most `min(n, size)`
+          # elements; cap that count so a huge `n` (or range) never blows up
+          # the Constant. `Range#size` is O(1) for integer endpoints.
+          return nil if [count, range.size].min > RANGE_TO_A_LIMIT
+
+          values = method_name == :last ? range.last(count) : range.first(count)
+          return Type::Combinator.tuple_of if values.empty?
+
+          Type::Combinator.tuple_of(*values.map { |v| Type::Combinator.constant_of(v) })
+        end
+
         def try_fold_binary_set(receiver_values, method_name, arg_values)
+          range_lift = try_fold_range_constant_binary(receiver_values, method_name, arg_values)
+          return range_lift if range_lift
+
           string_lift = try_fold_string_array_binary(receiver_values, method_name, arg_values)
           return string_lift if string_lift
 
+          integer_lift = try_fold_integer_array_binary(receiver_values, method_name, arg_values)
+          return integer_lift if integer_lift
+
           pathname_lift = try_fold_pathname_binary(receiver_values, method_name, arg_values)
           return pathname_lift if pathname_lift
 
@@ -456,15 +541,20 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values + arg_values)
         end
-        # v0.0.7 — `Constant<String>#chars` / `bytes` / `lines` /
-        # `split` (no-arg) return a Ruby Array of foldable
+        # v0.0.7 — `Constant<String>#chars` / `bytes` / `codepoints` /
+        # `lines` / `split` (no-arg) return a Ruby Array of foldable
         # scalars; `foldable_constant_value?` rejects Array
         # results, so the standard unary path declines. Lift the
         # Array to a per-position `Tuple[Constant…]` directly,
         # capped at `STRING_ARRAY_LIFT_LIMIT` to keep the result
-        # bounded for long strings.
-        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :lines, :split].freeze
-        STRING_ARRAY_BINARY_METHODS = Set[:split, :scan].freeze
+        # bounded for long strings. (`codepoints` yields per-character
+        # Integer codepoints, the sibling of the byte-valued `bytes`.)
+        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :codepoints, :lines, :split].freeze
+        # `partition` / `rpartition` always return a fixed 3-element
+        # `[head, separator, tail]` Array whose members are substrings of
+        # the receiver (bounded by the input), so they lift to a precise
+        # 3-slot `Tuple[Constant…]`.
+        STRING_ARRAY_BINARY_METHODS = Set[:split, :scan, :partition, :rpartition].freeze
         STRING_ARRAY_LIFT_LIMIT = 32
         private_constant :STRING_ARRAY_UNARY_METHODS,
                          :STRING_ARRAY_BINARY_METHODS,
@@ -494,6 +584,14 @@ module Rigor
         INTEGER_ARRAY_UNARY_METHODS = Set[:digits].freeze
         private_constant :INTEGER_ARRAY_UNARY_METHODS
 
+        # 1-arg Integer methods that return an Array of foldable
+        # Integers: `digits(base)` (base-n place values; raises on a
+        # negative receiver or base < 2 → declines) and `gcdlcm(other)`
+        # (the fixed `[gcd, lcm]` pair). Both are pure arithmetic; the
+        # result lifts to a `Tuple[Constant[Integer]…]`.
+        INTEGER_ARRAY_BINARY_METHODS = Set[:digits, :gcdlcm].freeze
+        private_constant :INTEGER_ARRAY_BINARY_METHODS
+
         # v0.0.7 — `Constant<Pathname>` delegates to a curated set
         # of pure path-manipulation methods. Pathname is immutable
         # in Ruby (per its docstring) and the catalog classifies
@@ -613,6 +711,25 @@ module Rigor
           nil
         end
 
+        # `Constant<Integer>#digits(base)` / `#gcdlcm(other)` — the
+        # 1-arg Array-returning Integer methods. `digits(base)` declines
+        # on a negative receiver (the unary path's guard); other domain
+        # errors (base < 2) raise and are rescued. `gcdlcm` is total over
+        # Integer args.
+        def try_fold_integer_array_binary(receiver_values, method_name, arg_values)
+          return nil unless INTEGER_ARRAY_BINARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1 && arg_values.size == 1
+
+          receiver = receiver_values.first
+          arg = arg_values.first
+          return nil unless receiver.is_a?(Integer) && arg.is_a?(Integer)
+          return nil if method_name == :digits && receiver.negative?
+
+          lift_array_result(receiver.public_send(method_name, arg))
+        rescue StandardError
+          nil
+        end
+
         # `Constant<Complex>#rect` / `#rectangular` — lifts `[real, imaginary]`
         # to `Tuple[Constant[re], Constant[im]]`. Both components are always
         # numeric (Integer or Float for literal complexes), so they satisfy
@@ -1334,7 +1451,24 @@ module Rigor
         private_constant :FOLDABLE_CONSTANT_CLASSES
 
         def foldable_constant_value?(value)
-          FOLDABLE_CONSTANT_CLASSES.any? { |klass| value.is_a?(klass) }
+          return false unless FOLDABLE_CONSTANT_CLASSES.any? { |klass| value.is_a?(klass) }
+
+          # A NaN result (`0.0 / 0.0`, `Float::NAN`-propagating arithmetic,
+          # or a NaN-bearing Complex) is non-reflexive under `==`, so a
+          # `Constant[NaN]` would break the `==` / `eql?` / `hash` contract
+          # `build_constant_type` relies on for union dedup. Decline the
+          # fold and let the RBS tier answer with the widened class.
+          return false if value.is_a?(Float) && value.nan?
+          return false if value.is_a?(Complex) && complex_nan?(value)
+
+          true
+        end
+
+        # True when either component of a Complex is NaN.
+        def complex_nan?(value)
+          real = value.real
+          imag = value.imaginary
+          (real.is_a?(Float) && real.nan?) || (imag.is_a?(Float) && imag.nan?)
         end
 
         def safe?(receiver_value, method_name, arg_value)
@@ -1355,6 +1489,7 @@ module Rigor
           when true, false    then BOOL_BINARY
           when nil            then NIL_BINARY
           when Rational       then RATIONAL_BINARY
+          when Complex        then COMPLEX_BINARY
           else                     Set.new
           end
         end