rigortype 0.3.1 → 0.3.3

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

@@ -18,7 +18,8 @@ module Rigor
       #
       # Catalogue (Slice 5 phase 2):
       #
-      # - Tuple#`first`, Tuple#`last`, Tuple#`size`/`length`/`count`: no-arg, no-block.
+      # - Tuple#`first`, Tuple#`last` (no-arg, or a single `Constant[Integer]` count lifting to a
+      #   sub-`Tuple`, the `take`/`drop` shape), Tuple#`size`/`length`/`count`: no-block.
       # - Tuple#`[]`, Tuple#`fetch` with a single `Constant[Integer]` argument inside the tuple's bounds
       #   (negative indices are normalised by length). Tuple#`[]` also handles static Range and
       #   start-length slices, returning a sliced Tuple or `Constant[nil]` for statically nil slices.
@@ -76,25 +77,48 @@ module Rigor
           fetch: :tuple_index,
           dig: :tuple_dig,
           values_at: :tuple_values_at,
+          # `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.
+          # `tuple.concat(other)` would fold correctly as a VALUE (same shape as `tuple + other`) but the
+          # receiver local/ivar would still carry the pre-concat Tuple afterward, which is unsound (#121).
+          # `MutationWidening.widen_after_call` is the actual precision mechanism for a mutator call site:
+          # it forgets the literal-arity carrier so a stale `size`/`empty?` fold cannot survive the
+          # mutation, rather than trying to fold the mutator itself.
           :+ => :tuple_concat,
           compact: :tuple_compact,
           take: :tuple_take,
           drop: :tuple_drop,
           rotate: :tuple_rotate,
           uniq: :tuple_uniq,
+          at: :tuple_at,
+          :& => :tuple_intersection,
+          intersection: :tuple_intersection,
+          :| => :tuple_union,
+          union: :tuple_union,
+          :- => :tuple_difference,
+          difference: :tuple_difference,
+          intersect?: :tuple_intersect?,
+          one?: :tuple_one?,
+          deconstruct: :shape_self,
           index: :tuple_find_index,
           find_index: :tuple_find_index,
           rindex: :tuple_rindex,
           flatten: :tuple_flatten,
           join: :tuple_join,
+          # `inspect` / `to_s` (an exact alias for Array — `Array#to_s` IS `Array#inspect`) — see
+          # {#tuple_inspect}, below the join helpers it shares a byte cap with.
+          inspect: :tuple_inspect,
+          to_s: :tuple_inspect,
+          :* => :tuple_star,
           freeze: :shape_self,
           dup: :shape_self,
           clone: :shape_self,
           itself: :shape_self
         }.freeze
 
-        # Byte cap on a folded `tuple.join` result — a huge tuple times a long separator must not
-        # materialise an unbounded `Constant`.
+        # Byte cap on a folded `tuple.join` / `tuple.inspect` / `hash.inspect` result — a huge tuple or
+        # shape must not materialise an unbounded `Constant`.
         TUPLE_JOIN_BYTE_LIMIT = 4096
         private_constant :TUPLE_JOIN_BYTE_LIMIT
 
@@ -115,6 +139,13 @@ module Rigor
           entries: :hash_to_a,
           to_h: :hash_to_h,
           to_hash: :hash_to_h,
+          # `inspect` / `to_s` (an exact alias for Hash — `Hash#to_s` IS `Hash#inspect`) — see
+          # {#hash_inspect}. Gated CLOSED-no-optional-key, same predicate `URIFolding#hash_form_pairs`
+          # uses for `URI.encode_www_form`'s HashShape argument: an open or partially-optional shape
+          # describes a hash whose real membership this fold cannot see, so its `inspect` string is not
+          # deterministic.
+          inspect: :hash_inspect,
+          to_s: :hash_inspect,
           deconstruct_keys: :hash_deconstruct_keys,
           invert: :hash_invert,
           merge: :hash_merge,
@@ -672,23 +703,39 @@ module Rigor
             Type::Combinator.integer_range(min, max)
           end
 
-          # `first` (no arg) → the first element (or `Constant[nil]` when empty). The `first(n)` arg-form
-          # is deliberately left to RBS overload selection (see the overload-selection specs) — folding it
-          # here would change that documented `Array[Elem]` contract.
+          # `first` (no arg) → the first element (or `Constant[nil]` when empty). `first(n)` → a `Tuple` of
+          # the leading `n` elements, the same `take`/`drop` shape via `non_negative_count_arg` (`n >= size`
+          # returns the full receiver, a non-static or negative count declines to RBS).
           def tuple_first(tuple, _method_name, args)
-            return nil unless args.empty?
+            return tuple_first_n(tuple, args) unless args.empty?
             return Type::Combinator.constant_of(nil) if tuple.elements.empty?
 
             tuple.elements.first
           end
 
+          def tuple_first_n(tuple, args)
+            n = non_negative_count_arg(args)
+            return nil if n.nil?
+
+            Type::Combinator.tuple_of(*tuple.elements.first(n))
+          end
+
+          # `last` (no arg) → the last element (or `Constant[nil]` when empty). `last(n)` → a `Tuple` of the
+          # trailing `n` elements, mirroring `tuple_first_n`.
           def tuple_last(tuple, _method_name, args)
-            return nil unless args.empty?
+            return tuple_last_n(tuple, args) unless args.empty?
             return Type::Combinator.constant_of(nil) if tuple.elements.empty?
 
             tuple.elements.last
           end
 
+          def tuple_last_n(tuple, args)
+            n = non_negative_count_arg(args)
+            return nil if n.nil?
+
+            Type::Combinator.tuple_of(*tuple.elements.last(n))
+          end
+
           def tuple_size(tuple, _method_name, args)
             return nil unless args.empty?
 
@@ -796,6 +843,59 @@ module Rigor
             arg.value
           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.
+          def tuple_inspect(tuple, _method_name, args)
+            return nil unless args.empty?
+
+            values = constant_values(tuple.elements)
+            return nil if values.nil?
+
+            result = values.inspect
+            return nil if result.bytesize > TUPLE_JOIN_BYTE_LIMIT
+
+            Type::Combinator.constant_of(result)
+          rescue StandardError
+            nil
+          end
+
+          # `tuple * n` — a `Constant[String]` argument is `Array#*`'s join-alias form (identical semantics
+          # to `#join`); a `Constant[Integer]` argument is repetition. Any other argument shape (2+ args,
+          # `Dynamic`, `Float`, no args) declines so the RBS / alias-pass tier answers — for the Integer
+          # case that tier already gives a decent union-of-elements `Array[...]` answer, so a decline here
+          # is not a regression.
+          def tuple_star(tuple, _method_name, args)
+            return nil unless args.size == 1
+
+            arg = args.first
+            return nil unless arg.is_a?(Type::Constant)
+
+            case arg.value
+            when String then tuple_join(tuple, :join, args)
+            when Integer then tuple_repeat(tuple, arg.value)
+            end
+          end
+
+          # `tuple * n` repetition. `n == 0` folds to the empty Tuple (any array repeated 0 times is `[]`,
+          # even for an unbounded/empty receiver). A negative `n` declines — `Array#*` raises
+          # `ArgumentError` at runtime, so no fold should invent a value for it (same fail-soft discipline
+          # every other handler in this catalogue follows). The result element count is capped at
+          # `MAX_SET_OPERATION_SIZE` (64) — the same element-count-cap convention as
+          # `ShellwordsFolding::SHELLWORDS_SPLIT_LIMIT` / `RegexpFolding`'s `Regexp.union` cap / the Tuple
+          # set operations above, reused rather than minting a second constant with the same value.
+          def tuple_repeat(tuple, count)
+            return nil if count.negative?
+            return Type::Combinator.tuple_of if count.zero?
+
+            total = tuple.elements.size * count
+            return nil if total > MAX_SET_OPERATION_SIZE
+
+            Type::Combinator.tuple_of(*(tuple.elements * count))
+          end
+
           # `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)`
@@ -957,6 +1057,88 @@ module Rigor
 
           # `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}: `[]`
+          # and `slice` accept a Range or a `(start, length)` pair, while `Array#at` raises `ArgumentError`
+          # on anything but one Integer, and a fold must never invent a value for a call that raises.
+          #
+          # An out-of-range index declines rather than folding to `Constant[nil]`, matching {#tuple_index}.
+          # Ruby really does return nil there, so the fold would be correct — but it would also turn a
+          # receiver the RBS tier types as `Elem?` into a proven nil, newly surfacing diagnostics on code
+          # that may be guarded in ways a shape cannot see. Precision that fires a new diagnostic is a
+          # separate decision from precision that removes a `Dynamic` (#121).
+          def tuple_at(tuple, _method_name, args)
+            return nil unless args.size == 1
+            return nil unless args.first.is_a?(Type::Constant) && args.first.value.is_a?(Integer)
+
+            tuple.elements[args.first.value]
+          end
+
+          # `a & b` / `a.intersection(b, ...)`, `a | b` / `a.union(...)`, `a - b` / `a.difference(...)`.
+          # 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)
+            set_operation(tuple, args) { |values, others| others.reduce(values, :&) }
+          end
+
+          def tuple_union(tuple, _method_name, args)
+            set_operation(tuple, args) { |values, others| others.reduce(values, :|) }
+          end
+
+          def tuple_difference(tuple, _method_name, args)
+            set_operation(tuple, args) { |values, others| others.reduce(values, :-) }
+          end
+
+          # `a.intersect?(b)` — the predicate form, `Constant[bool]`. `nil` is the decline signal every
+          # handler shares, not a boolean answer, so the predicate-return cop is disabled as it is for the
+          # other `?`-named handlers above.
+          # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
+          def tuple_intersect?(tuple, _method_name, args)
+            result = set_operation(tuple, args) { |values, others| others.reduce(values, :&) }
+            return nil if result.nil?
+
+            Type::Combinator.constant_of(!result.elements.empty?)
+          end
+
+          # 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.
+          def set_operation(tuple, args)
+            return nil if args.empty? || args.size > MAX_SET_OPERATION_ARITY
+
+            values = constant_values(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)
+            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) })
+          end
+
+          # An argument list longer than this, or a result wider than this, declines to the RBS tier rather
+          # than materialising an unbounded Tuple — the same discipline as {MAX_ZIP_ARITY} / the join cap.
+          MAX_SET_OPERATION_ARITY = 8
+          MAX_SET_OPERATION_SIZE = 64
+          private_constant :MAX_SET_OPERATION_ARITY, :MAX_SET_OPERATION_SIZE
+
+          # `one?` with no block and no pattern — `Constant[bool]` of "exactly one truthy element". Only
+          # `Constant` elements have decidable truthiness, and the block / pattern forms defer.
+          def tuple_one?(tuple, _method_name, args)
+            return nil unless args.empty?
+
+            values = constant_values(tuple.elements)
+            return nil if values.nil?
+
+            Type::Combinator.constant_of(values.one? { |value| value })
+          end
+          # rubocop:enable Style/ReturnNilInPredicateMethodDefinition
+
           def tuple_concat(tuple, _method_name, args)
             return nil unless args.size == 1
 
@@ -1487,6 +1669,28 @@ module Rigor
             shape
           end
 
+          # `shape.inspect` / `shape.to_s` (`Hash#to_s` is an exact alias of `Hash#inspect`) — folds only
+          # on a CLOSED shape with no optional keys (an open or partially-optional shape's real membership
+          # is not fully known, so its `inspect` string is not deterministic — the same gate
+          # `URIFolding#hash_form_pairs` uses for `URI.encode_www_form`'s HashShape argument) and only when
+          # every value is a `Constant` ({#constant_pairs}). Reconstructs the Ruby Hash and calls the REAL
+          # `inspect` so the analyzer matches Ruby 4.0.x's `{a: 1}` hash-inspect format rather than
+          # re-deriving it. Capped at `TUPLE_JOIN_BYTE_LIMIT` like the Tuple sibling.
+          def hash_inspect(shape, _method_name, args)
+            return nil unless args.empty?
+            return nil unless shape.closed? && shape.optional_keys.empty?
+
+            pairs = constant_pairs(shape)
+            return nil if pairs.nil?
+
+            result = pairs.inspect
+            return nil if result.bytesize > TUPLE_JOIN_BYTE_LIMIT
+
+            Type::Combinator.constant_of(result)
+          rescue StandardError
+            nil
+          end
+
           # `shape.invert` — swaps keys and values. Folds when every value is a `Constant` whose value is a
           # scalar the carrier accepts as a key (Symbol / String / Integer / Float / true / false / nil;
           # see {#static_shape_key?}). Duplicate values
@@ -1558,13 +1762,16 @@ module Rigor
             Type::Combinator.hash_shape_of(shape.pairs.merge(other.pairs))
           end
 
-          # `shape[k]` and `shape.fetch(k)` for a value-pinned scalar key. Missing-key resolution depends
-          # on the method:
+          # `shape[k]` and `shape.fetch(k)` for a value-pinned scalar key. On a CLOSED shape a key outside
+          # `pairs` is provably missing, and the resolution depends on the method:
           #
           # - `[]` returns `nil` at runtime; we surface `Constant[nil]` so the carrier is visible to
           #   downstream narrowing.
           # - `fetch` (no default, no block) raises `KeyError`; we let the projection answer apply because
           #   the runtime would not produce a value.
+          #
+          # On an `:open` shape neither applies — the key is unknown rather than missing, so both methods
+          # answer the `untyped` step from {#hash_dig_step}.
           def hash_lookup(shape, method_name, args)
             return nil unless args.size == 1
 
@@ -1594,6 +1801,12 @@ module Rigor
           # Returns the per-step value type for a HashShape lookup (or `Constant[nil]` for a known-missing
           # key). Returns `nil` when the argument is not a value-pinned scalar key so the caller can fall
           # through to the projection answer.
+          #
+          # A key outside `pairs` only resolves to `Constant[nil]` on a CLOSED shape, where `pairs` is the
+          # whole key set and the runtime read provably returns nil. On an `:open` shape the key set is by
+          # definition not exhausted, so an undeclared key is *unknown*, not absent — it may hold a value
+          # of any type. Typing it `Constant[nil]` there would put `call.undefined-method` on the next line
+          # of correct code (`payload[:undeclared].upcase`), so the open case answers `untyped`.
           def hash_dig_step(shape, arg)
             return nil unless arg.is_a?(Type::Constant)
 
@@ -1607,6 +1820,8 @@ module Rigor
               return Type::Combinator.union(value, Type::Combinator.constant_of(nil))
             end
 
+            return Type::Combinator.untyped if shape.open?
+
             Type::Combinator.constant_of(nil)
           end
 
@@ -1616,8 +1831,13 @@ module Rigor
             shape.optional_key?(arg.value)
           end
 
+          # Whether the key is provably ABSENT — which only a closed shape can establish. An open shape
+          # permits keys outside `pairs`, so a key it does not declare is unknown rather than missing, and
+          # `fetch` must not be deferred on the theory that Ruby would raise `KeyError`: the key may well
+          # be there. {#hash_dig_step} has already answered `untyped` for that case.
           def missing_key_step?(shape, arg)
             return false unless arg.is_a?(Type::Constant)
+            return false if shape.open?
 
             !shape.pairs.key?(arg.value)
           end
@@ -1685,7 +1905,9 @@ module Rigor
 
           # Continues a `dig` chain after the first step. Tuple and HashShape members re-dispatch into the
           # catalogue; `Constant[nil]` short-circuits the chain (Hash#dig and Array#dig do the same at
-          # runtime); anything else falls through so the projection answer applies.
+          # runtime); an `untyped` step (an undeclared key on an open shape) keeps the whole chain
+          # `untyped`, since digging further into an unknown value cannot recover a bound; anything else
+          # falls through so the projection answer applies.
           def chain_dig(receiver, args)
             return receiver if args.empty?
 
@@ -1693,6 +1915,7 @@ module Rigor
             when Type::Tuple then tuple_dig(receiver, :dig, args)
             when Type::HashShape then hash_dig(receiver, :dig, args)
             when Type::Constant then receiver.value.nil? ? Type::Combinator.constant_of(nil) : nil
+            when Type::Dynamic then Type::Combinator.untyped
             end
           end
         end

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

@@ -141,7 +141,7 @@ module Rigor
           map = member_map_for_new(members, keyword_init, context)
           return degraded_instance if map.nil?
 
-          Type::Combinator.struct_instance_of(members: map, class_name: class_name)
+          Type::Combinator.struct_instance_of(members: widen_unowned_emptiness(map), class_name: class_name)
         end
 
         # Builds the member -> type map honouring the class's `keyword_init` flag: a `keyword_init: true`
@@ -309,7 +309,8 @@ module Rigor
           return scope if member.nil?
 
           rebound = Type::Combinator.struct_instance_of(
-            members: current.members.merge(member => assigned_type), class_name: current.class_name
+            members: widen_unowned_emptiness(current.members.merge(member => assigned_type)),
+            class_name: current.class_name
           )
           scope.with_local(receiver.name, rebound)
         end

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

@@ -20,12 +20,31 @@ module Rigor
       #   decode. Returns `Constant[String]`.
       # * `encode_uri_component(str)` / `decode_uri_component(str)` — Same encoding but may preserve
       #   additional reserved chars (Ruby 3.2+). Returns `Constant[String]`.
+      # * `encode_www_form(enum)` — the whole-form encoder, over a `Tuple` of `[key, value]` `Tuple`s (an
+      #   array literal) or a `HashShape` (a hash literal) whose keys and values are all `Constant`.
+      #   Returns `Constant[String]`.
+      # * `decode_www_form(str)` — the inverse, over a `Constant[String]`. Returns a `Tuple` of two-element
+      #   `Tuple[Constant[String], Constant[String]]` pairs rather than the RBS tier's
+      #   `Array[[String, String]]`, so a destructuring read of a known form gets the concrete strings.
+      # * `extract(str)` — the URIs a constant string contains, as a `Tuple` of `Constant[String]` rather
+      #   than `Array[String]`. Single-argument form only (see {.fold_extract}).
+      #
+      # === Deliberately NOT folded
+      #
+      # `URI.parse` and `URI.join` are the two remaining gaps in this module's coverage note, and both are
+      # declined on the repo's own existing rule rather than on judgement: they return `URI::Generic` and
+      # friends, which are absent from `ConstantFolding::FOLDABLE_CONSTANT_CLASSES`, so there is no
+      # `Constant[…]` for this tier to produce. Narrowing `URI.parse`'s ten-arm return union to the one
+      # scheme class a constant string selects WOULD be a real precision win, but it makes a gradually-valid
+      # dispatch precise and can therefore surface a diagnostic that does not fire today — which puts it in
+      # the bucket-3 / P0 category, not in this FP-safe fold category ([#121](
+      # https://github.com/rigortype/rigor/issues/121)).
       #
       # === Non-constant / unsupported cases
       #
       # Returns `nil` (deferring to the next dispatcher tier) when:
       # - the receiver is not `Singleton[URI]`,
-      # - the first argument is not a `Constant[String]`,
+      # - an argument is not the constant shape the method's fold requires,
       # - the method is not in the supported set.
       module URIFolding
         URI_COMPONENT_METHODS = Set[
@@ -34,6 +53,12 @@ module Rigor
         ].freeze
         private_constant :URI_COMPONENT_METHODS
 
+        # A form long enough to suggest generated or accumulated data rather than a literal a reader wrote;
+        # past it the folded `Constant[String]` stops being useful in a diagnostic and only costs memory.
+        # Mirrors the byte ceiling `ShapeDispatch`'s own `tuple_join` fold applies for the same reason.
+        FORM_PAIR_LIMIT = 64
+        private_constant :FORM_PAIR_LIMIT
+
         module_function
 
         # @return [Rigor::Type, nil] folded result, or nil to defer.
@@ -42,11 +67,109 @@ module Rigor
           method_name = context.method_name
           args = context.args
           return nil unless SingletonFolding.receiver?(receiver, "URI")
+          return fold_encode_www_form(args) if method_name == :encode_www_form
+          return fold_decode_www_form(args) if method_name == :decode_www_form
+          return fold_extract(args) if method_name == :extract
           return nil unless URI_COMPONENT_METHODS.include?(method_name)
 
           fold_uri_call(method_name, args)
         end
 
+        # `URI.encode_www_form(enum)` — deterministic over its whole input, so it folds only when EVERY key
+        # and value is already a `Constant`. One non-constant pair declines the whole call: a partially
+        # known form has no `Constant[String]` to stand for it.
+        def fold_encode_www_form(args)
+          return nil unless args.size == 1
+
+          pairs = form_pairs(args.first)
+          return nil if pairs.nil? || pairs.size > FORM_PAIR_LIMIT
+
+          Type::Combinator.constant_of(URI.encode_www_form(pairs))
+        rescue StandardError
+          nil
+        end
+
+        # The `[key, value]` pairs of a literal form argument, or nil when the shape is not fully known:
+        # a `Tuple` of two-element `Tuple`s (the array-of-pairs spelling) or a `HashShape` (the hash
+        # spelling). `HashShape` pairs are read only when the shape is CLOSED and carries no optional key —
+        # an open or partially-optional shape describes a hash whose real contents this fold cannot see.
+        def form_pairs(arg)
+          case arg
+          when Type::Tuple then tuple_form_pairs(arg)
+          when Type::HashShape then hash_form_pairs(arg)
+          end
+        end
+
+        def tuple_form_pairs(tuple)
+          tuple.elements.map do |element|
+            return nil unless element.is_a?(Type::Tuple) && element.elements.size == 2
+            return nil unless element.elements.all?(Type::Constant)
+
+            element.elements.map(&:value)
+          end
+        end
+
+        def hash_form_pairs(shape)
+          return nil unless shape.closed? && shape.optional_keys.empty?
+
+          shape.pairs.map do |key, value|
+            return nil unless value.is_a?(Type::Constant)
+
+            [key, value.value]
+          end
+        end
+
+        # `URI.decode_www_form(str)` — the pair list of a constant form, as a `Tuple` of two-element
+        # `Tuple`s so a destructuring read (`k, v = URI.decode_www_form(s).first`) reaches the concrete
+        # strings instead of the RBS tier's `Array[[String, String]]`.
+        def fold_decode_www_form(args)
+          return nil unless args.size == 1
+
+          str = SingletonFolding.constant_string(args.first)
+          return nil if str.nil?
+
+          pairs = URI.decode_www_form(str)
+          return nil if pairs.size > FORM_PAIR_LIMIT
+
+          Type::Combinator.tuple_of(*pairs.map { |key, value| constant_pair(key, value) })
+        rescue StandardError
+          nil
+        end
+
+        def constant_pair(key, value)
+          Type::Combinator.tuple_of(Type::Combinator.constant_of(key), Type::Combinator.constant_of(value))
+        end
+
+        # `URI.extract(str)` — the URIs a constant string contains, as a `Tuple` of `Constant[String]`
+        # instead of the RBS tier's `Array[String]`. Only the single-argument form folds: the optional
+        # second argument is a schema FILTER, and honouring it means reproducing `URI.extract`'s own
+        # argument handling rather than the one call this fold makes, so it declines instead.
+        #
+        # Ruby emits an obsolescence warning for this method under `$VERBOSE`; the fold calls it with
+        # warnings silenced, because a warning about the ANALYZED program's API choice must not appear on
+        # the analyzer's own stderr, where a reader would attribute it to Rigor.
+        def fold_extract(args)
+          return nil unless args.size == 1
+
+          str = SingletonFolding.constant_string(args.first)
+          return nil if str.nil?
+
+          found = silence_warnings { URI.extract(str) }
+          return nil if found.nil? || found.size > FORM_PAIR_LIMIT
+
+          Type::Combinator.tuple_of(*found.map { |uri| Type::Combinator.constant_of(uri) })
+        rescue StandardError
+          nil
+        end
+
+        def silence_warnings
+          previous = $VERBOSE
+          $VERBOSE = nil
+          yield
+        ensure
+          $VERBOSE = previous
+        end
+
         def fold_uri_call(method_name, args)
           return nil unless args.size == 1
 

data/lib/rigor/inference/method_dispatcher.rb

@@ -6,6 +6,7 @@ require_relative "../flow_contribution"
 require_relative "../flow_contribution/merger"
 require_relative "../builtins/hkt_builtins"
 require_relative "../builtins/static_return_refinements"
+require_relative "anonymous_meta_class"
 require_relative "dynamic_origin"
 require_relative "flow_tracer"
 require_relative "void_tail_summary"
@@ -760,7 +761,7 @@ module Rigor
         struct_result = StructFolding.try_dispatch(context)
         return struct_result if struct_result
 
-        meta_result = try_meta_introspection(context.receiver, context.method_name, context.args)
+        meta_result = try_meta_introspection(context.receiver, context.method_name, context.args, context)
         return meta_result if meta_result
 
         PRECISE_TIERS_HEAD.each do |tier|
@@ -868,10 +869,10 @@ module Rigor
       # `Foo.class` as `Singleton[Class]` (deliberate; calling `.class` on a class object yields
       # `Class`, the metaclass). We also special-case `is_a?`-adjacent calls and the trivial
       # `instance_of?(self)` later as the rule catalogue grows; for now only `class` is handled.
-      def try_meta_introspection(receiver_type, method_name, arg_types = [])
+      def try_meta_introspection(receiver_type, method_name, arg_types = [], context = nil)
         case method_name
         when :class then meta_class(receiver_type)
-        when :new then meta_new(receiver_type, arg_types)
+        when :new then meta_new(receiver_type, arg_types, context)
         end
       end
 
@@ -891,13 +892,13 @@ module Rigor
       # `Type::Constant::SCALAR_CLASSES` accepts (today: `Pathname`), `.new(Constant<…>)` lifts
       # to a `Constant<…>` carrier so downstream method calls fold through the standard catalog
       # tier.
-      def meta_new(receiver_type, arg_types = [])
+      def meta_new(receiver_type, arg_types = [], context = nil)
         return nil unless receiver_type.is_a?(Type::Singleton)
 
         constant_lift = constant_constructor_lift(receiver_type.class_name, arg_types)
         return constant_lift if constant_lift
 
-        array_lift = array_new_lift(receiver_type.class_name, arg_types)
+        array_lift = array_new_lift(receiver_type.class_name, arg_types, context&.block_type)
         return array_lift if array_lift
 
         range_lift = range_new_lift(receiver_type.class_name, arg_types)
@@ -918,7 +919,7 @@ module Rigor
         struct_new_lift = struct_new_lift(receiver_type.class_name, arg_types)
         return struct_new_lift if struct_new_lift
 
-        class_new_lift = class_new_lift(receiver_type.class_name, arg_types)
+        class_new_lift = class_new_lift(receiver_type.class_name, arg_types, context)
         return class_new_lift if class_new_lift
 
         Type::Combinator.nominal_of(receiver_type.class_name)
@@ -955,9 +956,22 @@ module Rigor
       # so `Singleton[Parent]` lets downstream `klass.some_class_method` resolve. No parent →
       # `singleton(Object)`. Anything else (dynamic parent, more than one positional, …) falls
       # back to `Nominal[Class]` via the surrounding `meta_new` tail.
-      def class_new_lift(class_name, arg_types)
+      # #319 — a `Class.new do ... end` with no parent is NOT `Object`: the block body is a class body, so the
+      # class owns whatever that body defines. Answering `Singleton[Object]` handed the call site `Object`'s
+      # zero-arity `new` and `Object`'s method surface, so an `initialize(bucket)` written right there produced
+      # `wrong number of arguments ... (given 1, expected 0)` on code Ruby runs happily. `ScopeIndexer` registers
+      # the body's methods under the call site's anonymous name; return that name so the lookups reach them.
+      #
+      # Scoped to the parentless form on purpose. `Class.new(Parent) { ... }` keeps `Singleton[Parent]`: the
+      # anonymous name would have to carry the full ancestor chain for `Parent`'s own surface to stay reachable,
+      # and the parentless case is where the false positive lives.
+      def class_new_lift(class_name, arg_types, context = nil)
         return nil unless class_name == "Class"
-        return Type::Combinator.singleton_of("Object") if arg_types.empty?
+
+        if arg_types.empty?
+          anonymous = anonymous_class_new_name(context)
+          return Type::Combinator.singleton_of(anonymous || "Object")
+        end
         return nil unless arg_types.size == 1
 
         parent = arg_types.first
@@ -966,6 +980,16 @@ module Rigor
         nil
       end
 
+      # The synthetic name `ScopeIndexer` keyed this call site's block body by, or nil when the context carries no
+      # call node (internal dispatcher callers) or the call has no block. The source path is passed through
+      # verbatim — including when it is nil, which is exactly what `ScopeIndexer` saw for the same file — so the
+      # two passes derive the same name whether or not the caller supplied a path.
+      def anonymous_class_new_name(context)
+        return nil if context.nil?
+
+        AnonymousMetaClass.name_for(context.call_node, context.scope&.source_path)
+      end
+
       # ADR-15 Phase 4b.x — `Ractor.make_shareable` on both the outer Hash and each lambda value.
       # A plain `.freeze` leaves the Procs unshareable; reading `CONSTANT_CONSTRUCTORS[class]`
       # from a worker Ractor would raise `Ractor::IsolationError`, which the `rescue
@@ -1000,17 +1024,24 @@ module Rigor
       # `Tuple[…]` when `n` is a small `Constant<Integer>`. Cap at `ARRAY_NEW_TUPLE_LIMIT` (16)
       # so a `Array.new(1_000_000)` does not balloon the carrier; oversize calls fall back to
       # `Nominal[Array]`.
+      #
+      # #317 — `Array.new(n) { |i| ... }` fills every slot from the BLOCK's return type instead
+      # of the two-arg `(n, default_value)` overload's `nil` fill. The block and the trailing
+      # `default_value` positional are mutually exclusive per `Array#initialize`'s RBS overload
+      # set (`(int size, ?E default_value) -> void` vs `(int size) { (Integer index) -> E } ->
+      # void`), so a block present at the call site always wins over any (illegal, but tolerated
+      # rather than rejected here) second positional.
       ARRAY_NEW_TUPLE_LIMIT = 16
       private_constant :ARRAY_NEW_TUPLE_LIMIT
 
-      def array_new_lift(class_name, arg_types)
+      def array_new_lift(class_name, arg_types, block_type = nil)
         return nil unless class_name == "Array"
         return nil if arg_types.empty? || arg_types.size > 2
 
         size = array_new_size(arg_types.first)
         return nil if size.nil? || size.negative? || size > ARRAY_NEW_TUPLE_LIMIT
 
-        fill = array_new_fill(arg_types[1])
+        fill = block_type || array_new_fill(arg_types[1])
         Type::Combinator.tuple_of(*Array.new(size, fill))
       end