rigortype 0.4.6 → 0.4.8

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

@@ -57,12 +57,13 @@ module Rigor
           last: :tuple_last,
           size: :tuple_size,
           length: :tuple_size,
-          count: :tuple_size,
+          count: :tuple_count,
           empty?: :tuple_empty?,
           any?: :tuple_any?,
           all?: :tuple_all?,
           none?: :tuple_none?,
           include?: :tuple_include?,
+          member?: :tuple_include?,
           sum: :tuple_sum,
           min: :tuple_min,
           max: :tuple_max,
@@ -70,13 +71,23 @@ module Rigor
           sort: :tuple_sort,
           reverse: :tuple_reverse,
           to_a: :tuple_to_a,
+          entries: :tuple_to_a,
+          to_ary: :tuple_to_a,
           to_h: :tuple_to_h,
+          to_set: :tuple_to_set,
           zip: :tuple_zip,
           :[] => :tuple_index,
           slice: :tuple_index,
           fetch: :tuple_index,
           dig: :tuple_dig,
           values_at: :tuple_values_at,
+          fetch_values: :tuple_fetch_values,
+          assoc: :tuple_assoc,
+          rassoc: :tuple_rassoc,
+          tally: :tuple_tally,
+          transpose: :tuple_transpose,
+          product: :tuple_product,
+          pack: :tuple_pack,
           # `concat` / `<<` are deliberately ABSENT from this table: both mutate the receiver in place
           # (`ARRAY_MUTATORS` in `MutationWidening`), and a fold tier has no way to write the folded
           # result back into the caller's binding — it can only return a value for the call expression.
@@ -194,6 +205,7 @@ module Rigor
           Type::Tuple => :dispatch_tuple,
           Type::HashShape => :dispatch_hash_shape,
           Type::Nominal => :dispatch_nominal_size,
+          Type::Constant => :dispatch_constant_set,
           Type::Difference => :dispatch_difference,
           Type::Refined => :dispatch_refined,
           Type::Intersection => :dispatch_intersection,
@@ -215,6 +227,7 @@ module Rigor
           # `CONST = [...].freeze; CONST.any? { … }`; fixing it at the fold (not the rule) unblocks that
           # preservation.
           return nil unless context.block_type.nil?
+          return constant_set_first(context) if method_name == :first && receiver.is_a?(Type::Constant)
 
           handler = RECEIVER_HANDLERS[receiver.class]
           return nil unless handler
@@ -302,9 +315,62 @@ module Rigor
               when :flatten then array_nominal_flatten(nominal, args)
               when :compact then array_nominal_compact(nominal, args)
               end
+            when "Set"
+              set_nominal_algebra(nominal, method_name, args)
             end
           end
 
+          # The Set algebra that returns a new Set holding both operands' elements (issue #2294). RBS declares each
+          # as `(_Each[A]) -> Set[A]`, the receiver's element alone, so `ARGV.to_set | [1]` read `Set[String]` and a
+          # read of its `1` reported on correct code. The result is `Set[E | F]`, `F` the argument's elements with
+          # their value pins dropped ({SetMutation.element_types}).
+          SET_UNION_ALGEBRA = %i[| union + ^].to_set.freeze
+          private_constant :SET_UNION_ALGEBRA
+
+          def set_nominal_algebra(nominal, method_name, args)
+            return nil unless SET_UNION_ALGEBRA.include?(method_name) && args.size == 1
+
+            receiver = nominal.type_args.size == 1 ? nominal.type_args.first : Type::Combinator.untyped
+            added = Inference::SetMutation.element_types(args.first).map { |t| MethodDispatcher.array_new_element(t) }
+            Type::Combinator.nominal_of("Set", type_args: [Type::Combinator.union(receiver, *added)])
+          end
+
+          # The same algebra on a constant-folded Set whose argument is not constant (two constants fold upstream in
+          # {ConstantFolding}): the receiver's members and the argument's elements, typed as #2290 types a
+          # `Set[...]` literal over non-constant members ({SetFolding.typed_set}).
+          def dispatch_constant_set(constant, method_name, args)
+            return nil unless SET_UNION_ALGEBRA.include?(method_name) && args.size == 1
+            return nil unless Inference::SetMutation.constant?(constant)
+
+            members = constant.value.map { |v| Type::Combinator.constant_of(v) }
+            SetFolding.typed_set(members + Inference::SetMutation.element_types(args.first)) ||
+              Type::Combinator.nominal_of("Set", type_args: [Type::Combinator.untyped])
+          end
+
+          # Issue #2657 — `Set#first` (no argument) on a constant-folded Set held in a LOCAL that provably nobody else
+          # can reach. RBS alone answers `E?` over a constant receiver whose `E` is unbound, so `Set["r"].first` read
+          # `Dynamic[top]?`. The answer is the literal's first member (insertion order), `nil` for the empty set.
+          #
+          # What is proved: the receiver is a bare local read whose binding carries the `:synthesised` construction
+          # fact, which {Inference::ConstructionEscape} withholds from a local that is referenced inside any block or
+          # lambda, passed as an argument, held in a container or an alias, receives a call outside its reader /
+          # iterator / modelled-mutator lists (`method`, `instance_eval`, `send`, a project-defined name), or lives in a
+          # body that calls `binding` / `eval`; and the modelled mutators (`clear`, `delete`, `<<`, ...) widen the
+          # carrier off `Constant[Set]` at the call itself.
+          # What is NOT covered, and keeps the RBS answer: a receiver that is not a local (an ivar, a global, a
+          # constant, a call result, a literal), and whatever the escape scan itself does not see.
+          def constant_set_first(context)
+            constant = context.receiver
+            return nil unless context.args.nil? || context.args.empty?
+            return nil unless Inference::SetMutation.constant?(constant)
+
+            node = context.call_node&.receiver
+            return nil unless node.is_a?(Prism::LocalVariableReadNode)
+            return nil unless context.scope&.construction_fact?(node.name)
+
+            Type::Combinator.constant_of(constant.value.first)
+          end
+
           # `Integer#to_s` / `Integer#inspect` (#993) on a bare `Nominal[Integer]` receiver, ahead of the
           # existing `:*` binary fold. `#inspect` takes no argument and matches `#to_s()` byte for byte, so
           # it routes through the same no-arg branch.
@@ -317,7 +383,7 @@ module Rigor
           end
 
           # `decimal-int-string`'s predicate (`/\A-?\d+\z/`) admits the optional sign, so — unlike the
-          # `IntegerRange#to_s` tier above, which declines a signed range because it cannot yet prove the
+          # `IntegerRange#to_s` tier below, which declines a signed range because it cannot yet prove the
           # sign is absent — a bare `Integer` (sign completely unknown) still reaches it for the base-10
           # case: base 10 is Ruby's default sign-and-digits grammar for every Integer. Any other base,
           # known or not statically known, drops to `non-empty-string`: `to_s(base)` never returns `""`,
@@ -422,14 +488,29 @@ module Rigor
           # Resolves the element type of a flattened `Array[element]`. Each `Array[U]` nesting level
           # contributes `U`; the per-level element types are unioned. `depth < 0` recurses without bound;
           # `depth == 0` stops (Ruby's `flatten(0)` is a no-op copy and returns the element unchanged).
+          #
+          # Issue #2427 — a `Tuple` element is an Array too and contributes the union of its own elements, each
+          # flattened one level deeper, and so does a `Tuple` member of a `Union` element. `ARGV.map { |x| [x] }`
+          # is `Array[[String]]`, and returning its `[String]` element unchanged made `.flatten.first.upcase`
+          # report `undefined method 'upcase' for [String]` on code Ruby runs.
+          #
+          # A nominal `Array[U]` member of a `Union` element is kept. RBS's `String#scan(Regexp)` answers
+          # `Array[String | Array[String?]]`, the `?` standing for an optional group, and flattening that member
+          # turned the idiomatic `str.scan(/k = (.+)/).flatten.map(&:strip)` into a `possible-nil-receiver` for a
+          # group that always matches.
           def flatten_nominal_element(element, depth)
             return element if depth.zero?
-            return element unless array_nominal?(element)
-
-            inner = element.type_args.first
-            return element if inner.nil?
 
-            flatten_nominal_element(inner, depth - 1)
+            case element
+            when Type::Tuple
+              Type::Combinator.union(*element.elements.map { |inner| flatten_nominal_element(inner, depth - 1) })
+            when Type::Union
+              Type::Combinator.union(*element.members.map do |member|
+                member.is_a?(Type::Tuple) ? flatten_nominal_element(member, depth) : member
+              end)
+            else
+              array_nominal?(element) ? flatten_nominal_element(element.type_args.first, depth - 1) : element
+            end
           end
 
           def array_nominal?(type)
@@ -472,7 +553,7 @@ module Rigor
           # leading sign. Base 10 is Ruby's decimal-literal grammar, so the result lifts to
           # `decimal-int-string`. Signed ranges fall through entirely (the result could carry a `-` sign
           # that `decimal-int-string` alone would need a sign proof for, matching the
-          # `Nominal[Integer]` tier's own signed-base-10 carve-out below).
+          # `Nominal[Integer]` tier's own signed-base-10 carve-out above).
           #
           # #1004 — every other base (a different literal, such as 8 or 16, or a value that is not
           # statically known) does NOT lift to `octal-int-string` / `hex-int-string`: those refinements'
@@ -621,10 +702,10 @@ module Rigor
             Type::Combinator.positive_int
           end
 
-          # Predicate-subset projections over a `Refined[base, predicate]` receiver. Today the catalogue is
-          # the String case-normalisation pair: `s.downcase` over a `lowercase-string` receiver folds to
-          # the same carrier (already lowercase), and `s.upcase` lifts a `lowercase-string` to
-          # `uppercase-string`. Symmetric rules apply with the predicates swapped. Numeric-string
+          # Predicate-subset projections over a `Refined[base, predicate]` receiver. The catalogue is
+          # `REFINED_STRING_PROJECTIONS`, led by the String case-normalisation pair: `s.downcase` over a
+          # `lowercase-string` receiver folds to the same carrier (already lowercase), and `s.upcase` lifts a
+          # `lowercase-string` to `uppercase-string`. Symmetric rules apply with the predicates swapped. Numeric-string
           # idempotence over `#downcase` / `#upcase` is also recognised because a numeric string equals its
           # own case-normalisation.
           #
@@ -747,7 +828,7 @@ module Rigor
           # Compute the bounded-integer meet of two or more `IntegerRange` carriers. We compare via the
           # numeric `lower` / `upper` accessors (`-Float::INFINITY` / `Float::INFINITY` for the symbolic
           # ends), then map back to the symbolic-bound representation `IntegerRange.new` expects. The
-          # disjoint-meet case cannot arise from sound member-wise projections in v0.0.4 but is guarded
+          # disjoint-meet case cannot arise from sound member-wise projections but is guarded
           # defensively to keep the carrier total.
           def narrow_integer_ranges(ranges)
             numeric_low = ranges.map(&:lower).max
@@ -798,6 +879,25 @@ module Rigor
             Type::Combinator.constant_of(tuple.elements.size)
           end
 
+          # `tuple.count` / `tuple.count(needle)` — 0-arg mirrors `#size`; 1-arg counts elements equal to
+          # `needle` (`==`) when the needle and every element are constant values or shapes (or folds to `0`
+          # on `[]`).
+          def tuple_count(tuple, _method_name, args)
+            return Type::Combinator.constant_of(tuple.elements.size) if args.empty?
+            return nil unless args.size == 1
+
+            needle = unwrap_constant_type(args.first)
+            return nil if needle.equal?(NOT_CONSTANT)
+            return Type::Combinator.constant_of(0) if tuple.elements.empty?
+
+            values = unwrap_constant_elements(tuple.elements)
+            return nil if values.nil?
+
+            Type::Combinator.constant_of(values.count { |v| v == needle })
+          rescue StandardError
+            nil
+          end
+
           # `tuple.empty?` — folds to a precise bool from the tuple's known arity.
           # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
           def tuple_empty?(tuple, _method_name, args)
@@ -839,27 +939,29 @@ module Rigor
             Type::Combinator.constant_of(decision)
           end
 
-          # `tuple.include?(needle)` — folds to a precise bool when the needle is a `Constant` and the
-          # tuple's elements are all `Constant` (so disjointness is checkable). If any element matches the
-          # needle's value the answer is `Constant[true]`; if every element is a Constant whose value is
-          # structurally distinct from the needle the answer is `Constant[false]`.
+          # `tuple.include?(needle)` — folds to a precise bool when the needle and elements are constant
+          # scalars or constant nested Tuple / HashShape values. If any element matches the needle's value
+          # the answer is `Constant[true]`; if every element is constant and structurally distinct from the
+          # needle the answer is `Constant[false]`.
           def tuple_include?(tuple, _method_name, args)
             return nil unless args.size == 1
 
-            needle = args.first
-            return nil unless needle.is_a?(Type::Constant)
+            needle = unwrap_constant_type(args.first)
+            return nil if needle.equal?(NOT_CONSTANT)
             return Type::Combinator.constant_of(false) if tuple.elements.empty?
 
-            return Type::Combinator.constant_of(true) if any_element_matches?(tuple.elements, needle.value)
-            return Type::Combinator.constant_of(false) if tuple.elements.all?(Type::Constant)
+            return Type::Combinator.constant_of(true) if any_element_matches?(tuple.elements, needle)
+            return Type::Combinator.constant_of(false) unless unwrap_constant_elements(tuple.elements).nil?
 
             nil
           end
           # rubocop:enable Style/ReturnNilInPredicateMethodDefinition
 
-          # `tuple.sum` — when every element is a numeric Constant, fold to `Constant[sum]`. Mixed /
-          # non-numeric elements decline so RBS widens.
+          # `tuple.sum` / `tuple.sum(init)` — when every element is a numeric Constant (and optional `init`
+          # is a numeric Constant), fold to `Constant[sum]`; when every element and `init` are String
+          # Constants, fold to `Constant[sum]` within `TUPLE_JOIN_BYTE_LIMIT`.
           def tuple_sum(tuple, _method_name, args)
+            return tuple_sum_with_init(tuple, args.first) if args.size == 1
             return nil unless args.empty?
             return Type::Combinator.constant_of(0) if tuple.elements.empty?
 
@@ -867,16 +969,45 @@ module Rigor
             return nil if values.nil?
 
             Type::Combinator.constant_of(values.sum)
+          rescue StandardError
+            nil
+          end
+
+          def tuple_sum_with_init(tuple, init)
+            return nil unless init.is_a?(Type::Constant)
+            return tuple_sum_with_string_init(tuple, init.value) if init.value.is_a?(String)
+            return nil unless init.value.is_a?(Numeric)
+            return init if tuple.elements.empty?
+
+            values = constant_numeric_values(tuple.elements)
+            return nil if values.nil?
+
+            Type::Combinator.constant_of(values.sum(init.value))
+          rescue StandardError
+            nil
+          end
+
+          def tuple_sum_with_string_init(tuple, init_str)
+            values = constant_values(tuple.elements)
+            return nil if values.nil? || !values.all?(String)
+            return nil if values.sum(&:bytesize) + init_str.bytesize > TUPLE_JOIN_BYTE_LIMIT
+
+            result = values.sum(init_str)
+            return nil if result.bytesize > TUPLE_JOIN_BYTE_LIMIT
+
+            Type::Combinator.constant_of(result)
+          rescue StandardError
+            nil
           end
 
           # `tuple.join(sep = "")` — fold to the joined `Constant[String]` when every element is a
-          # `Constant` (its `to_s` is deterministic for the scalar value classes) and the separator is
-          # absent or a `Constant[String]`. Capped at `TUPLE_JOIN_BYTE_LIMIT`.
+          # constant scalar or nested constant Tuple and the separator is absent or a `Constant[String]`.
+          # Capped at `TUPLE_JOIN_BYTE_LIMIT`.
           def tuple_join(tuple, _method_name, args)
             sep = tuple_join_separator(args)
             return nil if sep.nil?
 
-            values = constant_values(tuple.elements)
+            values = unwrap_constant_elements(tuple.elements)
             return nil if values.nil?
 
             result = values.join(sep)
@@ -900,14 +1031,13 @@ module Rigor
           end
 
           # `tuple.inspect` / `tuple.to_s` (`Array#to_s` is an exact alias of `Array#inspect`) — folds when
-          # every element is a `Constant`, by reconstructing the Ruby Array and calling the REAL `inspect`
-          # so the analyzer's Ruby (4.0.x's `Array#inspect` format) is matched rather than re-derived.
-          # Capped at `TUPLE_JOIN_BYTE_LIMIT` like `#join`, since a large tuple's `inspect` string is
-          # similarly unbounded.
+          # every element is a constant scalar or nested constant Tuple / HashShape, by reconstructing the
+          # Ruby Array and calling the REAL `inspect` so the analyzer's Ruby (4.0.x's `Array#inspect` format)
+          # is matched rather than re-derived. Capped at `TUPLE_JOIN_BYTE_LIMIT` like `#join`.
           def tuple_inspect(tuple, _method_name, args)
             return nil unless args.empty?
 
-            values = constant_values(tuple.elements)
+            values = unwrap_constant_elements(tuple.elements)
             return nil if values.nil?
 
             result = values.inspect
@@ -952,7 +1082,7 @@ module Rigor
             Type::Combinator.tuple_of(*(tuple.elements * count))
           end
 
-          # `tuple.min` / `tuple.max` — fold when every element is a `Constant` whose values share a
+          # `tuple.min` / `tuple.max` — fold when every element is a constant whose values share a
           # Ruby-comparable domain. Empty tuples fold to `Constant[nil]`. The 1-arg `min(n)` / `max(n)`
           # form folds to a `Tuple` of the n edge-most values in Ruby's order (`min(n)` ascending, `max(n)`
           # descending) — the n-arg sibling of `first(n)`.
@@ -968,11 +1098,11 @@ module Rigor
             return tuple_minmax_n(tuple, args.first, edge) unless args.empty?
             return Type::Combinator.constant_of(nil) if tuple.elements.empty?
 
-            values = constant_values(tuple.elements)
+            values = unwrap_constant_elements(tuple.elements)
             return nil if values.nil?
 
             result = values.public_send(edge)
-            Type::Combinator.constant_of(result)
+            lift_constant_value(result)
           rescue StandardError
             nil
           end
@@ -985,19 +1115,18 @@ module Rigor
             return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Integer)
             return nil if arg.value.negative?
 
-            values = constant_values(tuple.elements)
+            values = unwrap_constant_elements(tuple.elements)
             return nil if values.nil?
 
             picked = values.public_send(edge, arg.value)
-            Type::Combinator.tuple_of(*picked.map { |v| Type::Combinator.constant_of(v) })
+            Type::Combinator.tuple_of(*picked.map { |v| lift_constant_value(v) })
           rescue StandardError
             nil
           end
 
-          # `tuple.minmax` — the `[min, max]` pair as a 2-slot `Tuple[Constant[min], Constant[max]]`,
-          # mirroring the `Range#minmax` fold. Every element must be a `Constant` and the values must
-          # Ruby-compare; an empty tuple folds to `Tuple[nil, nil]` (Ruby's `[].minmax`), incomparable
-          # mixed-class values decline.
+          # `tuple.minmax` — the `[min, max]` pair as a 2-slot `Tuple`, mirroring the `Range#minmax` fold.
+          # Every element must be constant and the values must Ruby-compare; an empty tuple folds to
+          # `Tuple[nil, nil]` (Ruby's `[].minmax`), incomparable mixed-class values decline.
           def tuple_minmax_pair(tuple, _method_name, args)
             return nil unless args.empty?
 
@@ -1006,30 +1135,30 @@ module Rigor
               return Type::Combinator.tuple_of(nil_const, nil_const)
             end
 
-            values = constant_values(tuple.elements)
+            values = unwrap_constant_elements(tuple.elements)
             return nil if values.nil?
 
             low, high = values.minmax
             Type::Combinator.tuple_of(
-              Type::Combinator.constant_of(low),
-              Type::Combinator.constant_of(high)
+              lift_constant_value(low),
+              lift_constant_value(high)
             )
           rescue StandardError
             nil
           end
 
-          # `tuple.sort` — every element must be a `Constant` and the values must Ruby-compare. The result
+          # `tuple.sort` — every element must be constant and the values must Ruby-compare. The result
           # is a Tuple with the same elements in sorted order. Comparison failures (mixed-class
           # incomparable values) decline.
           def tuple_sort(tuple, _method_name, args)
             return nil unless args.empty?
             return tuple if tuple.elements.size <= 1
 
-            values = constant_values(tuple.elements)
+            values = unwrap_constant_elements(tuple.elements)
             return nil if values.nil?
 
             sorted = values.sort
-            Type::Combinator.tuple_of(*sorted.map { |v| Type::Combinator.constant_of(v) })
+            Type::Combinator.tuple_of(*sorted.map { |v| lift_constant_value(v) })
           rescue StandardError
             nil
           end
@@ -1056,7 +1185,7 @@ module Rigor
           # runtime semantics). Declines when any `other_k` is not a Tuple, since the arity is then unknown
           # and the result would be `Array[Array[…]]` — RBS already gives that answer.
           def tuple_zip(tuple, _method_name, args)
-            return nil if args.empty? || args.size > MAX_ZIP_ARITY
+            return nil if args.size > MAX_ZIP_ARITY
             return nil unless args.all?(Type::Tuple)
 
             zipped = tuple.elements.each_with_index.map do |elem, i|
@@ -1094,23 +1223,180 @@ module Rigor
             [key.value, value]
           end
 
-          # `tuple.values_at(i1, i2, ...)` — returns a Tuple of per-index elements. Each argument must be a
-          # `Constant[Integer]`. Out-of-range indices fill with `Constant[nil]`, mirroring Ruby's runtime
-          # behaviour. Declines when any argument is non-static.
+          # `tuple.to_set` — folds to `Constant[Set]` when every element is a `Constant`, matching
+          # `Set[...]` / `Set.new([...])`. Non-constant elements decline so RBS keeps `Set[Elem]`.
+          def tuple_to_set(tuple, _method_name, args)
+            return nil unless args.empty?
+
+            values = constant_values(tuple.elements)
+            return nil if values.nil?
+
+            Type::Combinator.constant_of(::Set.new(values))
+          rescue StandardError
+            nil
+          end
+
+          # `tuple.values_at(i1, i2, ...)` — returns a Tuple of per-index / per-range elements. Each
+          # argument must be a `Constant[Integer]` or a `Constant[Range]` with integer/endless/beginless
+          # endpoints. Out-of-range positive indices fill with `Constant[nil]`, mirroring Ruby's runtime
+          # behaviour. Declines when any argument is non-static, raises `RangeError`, or exceeds
+          # `MAX_SET_OPERATION_SIZE`.
           def tuple_values_at(tuple, _method_name, args)
-            return nil if args.empty?
+            return nil if args.empty? || args.size > MAX_SET_OPERATION_SIZE
+
+            raw_args = args.map do |arg|
+              return nil unless arg.is_a?(Type::Constant) && values_at_selector?(arg.value)
 
+              arg.value
+            end
+            picked = tuple.elements.values_at(*raw_args)
+            return nil if picked.size > MAX_SET_OPERATION_SIZE
+
+            Type::Combinator.tuple_of(*picked.map { |elem| elem || Type::Combinator.constant_of(nil) })
+          rescue StandardError
+            nil
+          end
+
+          def values_at_selector?(value)
+            return true if value.is_a?(Integer)
+            return false unless value.is_a?(Range) && integer_range?(value)
+
+            !(value.end.is_a?(Integer) && value.end > MAX_SET_OPERATION_SIZE)
+          end
+
+          # `tuple.fetch_values(i1, i2, ...)` — returns a Tuple of per-index elements when every argument
+          # is an in-bounds `Constant[Integer]`; an out-of-range or non-static index declines so RBS handles
+          # the possible `IndexError`.
+          def tuple_fetch_values(tuple, _method_name, args)
             values = args.map do |arg|
-              return nil unless arg.is_a?(Type::Constant)
-              return nil unless arg.value.is_a?(Integer)
+              return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Integer)
 
               idx = normalise_index(arg.value, tuple.elements.size)
-              idx ? tuple.elements[idx] : Type::Combinator.constant_of(nil)
+              return nil unless idx
+
+              tuple.elements[idx]
             end
 
             Type::Combinator.tuple_of(*values)
           end
 
+          # `tuple.assoc(needle)` / `tuple.rassoc(needle)` — scans inner Tuples in declaration order for a
+          # constant match at slot 0 (`assoc`) or slot 1 (`rassoc`). Known non-array scalars/hashes/ranges
+          # are skipped, while an earlier non-constant slot or opaque element declines.
+          def tuple_assoc(tuple, _method_name, args)
+            tuple_slot_lookup(tuple, args, slot_index: 0)
+          end
+
+          def tuple_rassoc(tuple, _method_name, args)
+            tuple_slot_lookup(tuple, args, slot_index: 1)
+          end
+
+          def tuple_slot_lookup(tuple, args, slot_index:)
+            return nil unless args.size == 1
+
+            needle = unwrap_constant_type(args.first)
+            return nil if needle.equal?(NOT_CONSTANT)
+
+            tuple.elements.each do |elem|
+              next if non_array_shape?(elem)
+              return nil unless elem.is_a?(Type::Tuple)
+
+              match = tuple_slot_match(elem, needle, slot_index)
+              return nil if match == :decline
+              return elem if match
+            end
+
+            Type::Combinator.constant_of(nil)
+          rescue StandardError
+            nil
+          end
+
+          def non_array_shape?(elem)
+            elem.is_a?(Type::Constant) || elem.is_a?(Type::HashShape) ||
+              elem.is_a?(Type::IntegerRange) || elem.is_a?(Type::FloatRange)
+          end
+
+          def tuple_slot_match(elem, needle, slot_index)
+            return false if elem.elements.size <= slot_index
+
+            slot = unwrap_constant_type(elem.elements[slot_index])
+            return :decline if slot.equal?(NOT_CONSTANT)
+
+            slot == needle
+          end
+
+          # `tuple.tally` — returns a closed `HashShape` of `value => Constant[count]` when every element
+          # is a `Constant` whose value is a valid static HashShape key.
+          def tuple_tally(tuple, _method_name, args)
+            return nil unless args.empty?
+
+            values = constant_values(tuple.elements)
+            return nil if values.nil?
+            return nil unless values.all? { |v| static_shape_key?(v) }
+
+            counts = values.tally.transform_values { |n| Type::Combinator.constant_of(n) }
+            Type::Combinator.hash_shape_of(counts)
+          end
+
+          # `tuple.transpose` — transposes a Tuple of equal-length Tuples into a Tuple of Tuples.
+          def tuple_transpose(tuple, _method_name, args)
+            return nil unless args.empty?
+            return tuple if tuple.elements.empty?
+            return nil unless tuple.elements.all?(Type::Tuple)
+
+            width = tuple.elements.first.elements.size
+            return nil unless tuple.elements.all? { |row| row.elements.size == width }
+
+            transposed = tuple.elements.map(&:elements).transpose
+            Type::Combinator.tuple_of(*transposed.map { |col| Type::Combinator.tuple_of(*col) })
+          end
+
+          # `tuple.product(other_1, ...)` — Cartesian product of Tuples, bounded by
+          # `MAX_SET_OPERATION_ARITY` and `MAX_SET_OPERATION_SIZE`.
+          def tuple_product(tuple, _method_name, args)
+            return nil if args.size > MAX_SET_OPERATION_ARITY
+            return nil unless args.all?(Type::Tuple)
+
+            total = args.reduce(tuple.elements.size) { |acc, other| acc * other.elements.size }
+            return nil if total > MAX_SET_OPERATION_SIZE
+            return Type::Combinator.tuple_of if total.zero?
+
+            pairs = tuple.elements.product(*args.map(&:elements))
+            Type::Combinator.tuple_of(*pairs.map { |row| Type::Combinator.tuple_of(*row) })
+          end
+
+          # `tuple.pack(template)` — folds to `Constant[String]` when all elements and template are
+          # `Constant` (excluding non-deterministic pointer directives `p`/`P` and numeric counts or offsets
+          # whose sum exceeds `TUPLE_JOIN_BYTE_LIMIT`), capped at `TUPLE_JOIN_BYTE_LIMIT`.
+          def tuple_pack(tuple, _method_name, args)
+            return nil unless args.size == 1
+
+            template = args.first
+            return nil unless template.is_a?(Type::Constant) && template.value.is_a?(String)
+            return nil if template.value.bytesize > TUPLE_JOIN_BYTE_LIMIT
+            return nil if template.value.match?(/[pP]/)
+            return nil if pack_count_exceeds_limit?(template.value)
+
+            values = constant_values(tuple.elements)
+            return nil if values.nil?
+
+            result = values.pack(template.value)
+            return nil if result.bytesize > TUPLE_JOIN_BYTE_LIMIT
+
+            Type::Combinator.constant_of(result)
+          rescue StandardError
+            nil
+          end
+
+          def pack_count_exceeds_limit?(template)
+            total = 0
+            template.scan(/\d+/) do |digits|
+              total += digits.to_i
+              return true if total > TUPLE_JOIN_BYTE_LIMIT
+            end
+            false
+          end
+
           # `tuple + other` — concatenates two Tuples. Both sides must be `Type::Tuple`. Returns a new
           # Tuple whose elements are those of the receiver followed by those of the argument.
           # `at(n)` — the strict single-Integer accessor. Deliberately NOT an alias of {#tuple_index}: `[]`
@@ -1133,15 +1419,33 @@ module Rigor
           # Every set operation is evaluated by running Ruby's own operator over the unwrapped values, which
           # is the only way to reproduce its `eql?` / `hash` semantics exactly — `[1] & [1.0]` is empty even
           # though `1 == 1.0`, so an equality-based reimplementation would fold the wrong answer.
-          def tuple_intersection(tuple, _method_name, args)
+          def tuple_intersection(tuple, method_name, args)
+            return tuple if method_name == :intersection && args.empty?
+
             set_operation(tuple, args) { |values, others| others.reduce(values, :&) }
           end
 
-          def tuple_union(tuple, _method_name, args)
+          def tuple_union(tuple, method_name, args)
+            return tuple_zero_arg_union(tuple) if method_name == :union && args.empty?
+
             set_operation(tuple, args) { |values, others| others.reduce(values, :|) }
           end
 
-          def tuple_difference(tuple, _method_name, args)
+          def tuple_zero_arg_union(tuple)
+            return tuple if tuple.elements.size <= 1
+
+            values = unwrap_constant_elements(tuple.elements)
+            return nil if values.nil?
+
+            result = values.union
+            return nil if result.size > MAX_SET_OPERATION_SIZE
+
+            Type::Combinator.tuple_of(*result.map { |value| lift_constant_value(value) })
+          end
+
+          def tuple_difference(tuple, method_name, args)
+            return tuple if method_name == :difference && args.empty?
+
             set_operation(tuple, args) { |values, others| others.reduce(values, :-) }
           end
 
@@ -1158,23 +1462,23 @@ module Rigor
 
           # Shared body for the set operations: unwrap the receiver and every Tuple argument, hand the raw
           # values to `block`, and lift the result back. Declines unless every element on both sides is a
-          # `Constant` (an unknown element makes membership undecidable) and every argument is a `Tuple` —
-          # `Array#&` also accepts anything that responds to `to_ary`, which a shape cannot prove.
+          # constant scalar or constant nested Tuple / HashShape (an unknown element makes membership
+          # undecidable) and every argument is a `Tuple`.
           def set_operation(tuple, args)
             return nil if args.empty? || args.size > MAX_SET_OPERATION_ARITY
 
-            values = constant_values(tuple.elements)
+            values = unwrap_constant_elements(tuple.elements)
             return nil if values.nil?
 
             others = args.map do |arg|
               return nil unless arg.is_a?(Type::Tuple)
 
-              constant_values(arg.elements) || (return nil)
+              unwrap_constant_elements(arg.elements) || (return nil)
             end
             result = yield(values, others)
             return nil if result.size > MAX_SET_OPERATION_SIZE
 
-            Type::Combinator.tuple_of(*result.map { |value| Type::Combinator.constant_of(value) })
+            Type::Combinator.tuple_of(*result.map { |value| lift_constant_value(value) })
           end
 
           # An argument list longer than this, or a result wider than this, declines to the RBS tier rather
@@ -1204,28 +1508,48 @@ module Rigor
             Type::Combinator.tuple_of(*tuple.elements, *other.elements)
           end
 
-          # `tuple.compact` — removes every element that is `Constant[nil]`. Folds only when every element
-          # is a `Constant` (so the nil set is decidable). Mixed-shape elements decline so the RBS tier
-          # widens.
+          # `tuple.compact` — removes every element that is `Constant[nil]`. When every element is a
+          # `Constant` the nil set is decidable and the result is the exact Tuple of the kept elements.
+          # Otherwise an element that may be nil leaves the arity unknown, so the result is `Array[E]` with
+          # `E` the elements' union minus its `nil` constituent (#2519) — never a fixed-arity Tuple. When
+          # no element carries a `nil` constituent there is nothing to strip and the method declines so
+          # the RBS tier answers (an element such as `Dynamic[top]` may still be nil at runtime, so the
+          # Tuple is not kept either).
           def tuple_compact(tuple, _method_name, args)
             return nil unless args.empty?
-            return nil unless tuple.elements.all?(Type::Constant)
 
-            kept = tuple.elements.reject { |e| e.is_a?(Type::Constant) && e.value.nil? }
-            Type::Combinator.tuple_of(*kept)
+            if tuple.elements.all?(Type::Constant)
+              kept = tuple.elements.reject { |e| e.value.nil? }
+              return Type::Combinator.tuple_of(*kept)
+            end
+
+            tuple_compact_widened(tuple.elements)
+          end
+
+          def tuple_compact_widened(elements)
+            stripped = elements.map { |e| strip_nil_constituent(e) }
+            return nil if stripped.zip(elements).all? { |s, e| s.equal?(e) }
+
+            element = Type::Combinator.union(*stripped)
+            return Type::Combinator.tuple_of if element.is_a?(Type::Bot)
+
+            Type::Combinator.nominal_of("Array", type_args: [element])
           end
 
           # `uniq` (no block) → `Tuple` of the first occurrence of each distinct value. Folds only when
-          # every element is a `Constant` so value equality is decidable; the block form defers.
+          # every element is a constant scalar or constant nested Tuple / HashShape so `eql?` identity is
+          # decidable; the block form defers.
           def tuple_uniq(tuple, _method_name, args)
             return nil unless args.empty?
-            return nil unless tuple.elements.all?(Type::Constant)
 
-            seen = []
-            kept = tuple.elements.each_with_object([]) do |element, acc|
-              next if seen.include?(element.value)
+            values = unwrap_constant_elements(tuple.elements)
+            return nil if values.nil?
+
+            seen = {}
+            kept = tuple.elements.zip(values).each_with_object([]) do |(element, value), acc|
+              next if seen.key?(value)
 
-              seen << element.value
+              seen[value] = true
               acc << element
             end
             Type::Combinator.tuple_of(*kept)
@@ -1233,9 +1557,9 @@ module Rigor
 
           # `index(obj)` / `find_index(obj)` → `Constant[Integer]` of the first element equal to `obj`,
           # `Constant[nil]` when none match. Folds only for the argument form (the block form defers) when
-          # every element AND the argument are `Constant` (decidable equality).
+          # every element AND the argument are constant (decidable equality).
           def tuple_find_index(tuple, _method_name, args)
-            constant_index(tuple, args) { |elements, value| elements.index { |e| e.value == value } }
+            constant_index(tuple, args) { |values, needle| values.index { |v| v == needle } }
           end
 
           # `tuple.flatten` / `tuple.flatten(depth)` — recursively flattens nested Tuple elements into a
@@ -1279,21 +1603,24 @@ module Rigor
 
           # `rindex(obj)` → the LAST matching index, same decidability gate.
           def tuple_rindex(tuple, _method_name, args)
-            constant_index(tuple, args) { |elements, value| elements.rindex { |e| e.value == value } }
+            constant_index(tuple, args) { |values, needle| values.rindex { |v| v == needle } }
           end
 
           def constant_index(tuple, args)
             return nil unless args.size == 1
 
-            needle = args.first
-            return nil unless needle.is_a?(Type::Constant)
-            return nil unless tuple.elements.all?(Type::Constant)
+            needle = unwrap_constant_type(args.first)
+            values = unwrap_constant_elements(tuple.elements)
+            return nil if needle.equal?(NOT_CONSTANT) || values.nil?
 
-            Type::Combinator.constant_of(yield(tuple.elements, needle.value))
+            Type::Combinator.constant_of(yield(values, needle))
+          rescue StandardError
+            nil
           end
 
           # `tuple.take(n)` — returns the first n elements as a new Tuple. The argument must be a
-          # `Constant[Integer]`. n <= 0 returns the empty Tuple; n >= size returns the full receiver.
+          # `Constant[Integer]`. `n == 0` returns the empty Tuple, a negative `n` declines, and `n >= size`
+          # returns the full receiver.
           def tuple_take(tuple, _method_name, args)
             n = non_negative_count_arg(args)
             return nil if n.nil?
@@ -1359,7 +1686,63 @@ module Rigor
           end
 
           def any_element_matches?(elements, value)
-            elements.any? { |e| e.is_a?(Type::Constant) && e.value == value }
+            elements.any? do |e|
+              unwrapped = unwrap_constant_type(e)
+              !unwrapped.equal?(NOT_CONSTANT) && unwrapped == value
+            end
+          end
+
+          NOT_CONSTANT = Object.new.freeze
+          private_constant :NOT_CONSTANT
+
+          # Unwraps a `Type::Constant`, a `Type::Tuple` of recursively constant elements, or a closed
+          # required-only `Type::HashShape` of recursively constant values into its plain Ruby value, or
+          # `NOT_CONSTANT` when any part is non-constant.
+          def unwrap_constant_type(type)
+            case type
+            when Type::Constant
+              type.value
+            when Type::Tuple
+              values = unwrap_constant_elements(type.elements)
+              values.nil? ? NOT_CONSTANT : values
+            when Type::HashShape
+              unwrap_constant_hash_shape(type)
+            else
+              NOT_CONSTANT
+            end
+          end
+
+          def unwrap_constant_hash_shape(shape)
+            return NOT_CONSTANT unless shape.closed? && shape.optional_keys.empty?
+
+            pairs = {}
+            shape.pairs.each do |k, v|
+              unwrapped = unwrap_constant_type(v)
+              return NOT_CONSTANT if unwrapped.equal?(NOT_CONSTANT)
+
+              pairs[k] = unwrapped
+            end
+            pairs
+          end
+
+          def unwrap_constant_elements(elements)
+            elements.map do |elem|
+              val = unwrap_constant_type(elem)
+              return nil if val.equal?(NOT_CONSTANT)
+
+              val
+            end
+          end
+
+          def lift_constant_value(value)
+            case value
+            when Array
+              Type::Combinator.tuple_of(*value.map { |v| lift_constant_value(v) })
+            when Hash
+              Type::Combinator.hash_shape_of(value.transform_values { |v| lift_constant_value(v) })
+            else
+              Type::Combinator.constant_of(value)
+            end
           end
 
           # Per-element Constant value extraction. Returns nil when any element is non-Constant, so the
@@ -1919,7 +2302,7 @@ module Rigor
           # `shape.values_at(:a, :b, ...)` with a list of static keys. Returns a `Tuple` whose per-position
           # values are the per-key value types (`Constant[nil]` for missing keys, mirroring Ruby's runtime
           # behaviour). A computed key takes the nil-bearing step {#hash_dig_step} gives it; the call falls
-          # through when any step does (a computed key on an open shape).
+          # through when any step does (a computed key on an open or empty shape).
           def hash_values_at(shape, _method_name, args)
             return nil if args.empty?