rigortype 0.1.19 → 0.2.1

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,35 @@ 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?,
+          # `finite?` / `infinite?` are total on Integer (`true` / `nil`
+          # always) and round out the numeric predicate family — the Float
+          # sibling already folds them. `nonzero?` returns `self` (non-zero)
+          # or `nil`, both foldable Constants.
+          :finite?, :infinite?, :nonzero?,
           :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?,
+          :zero?, :positive?, :negative?, :nonzero?,
+          :nan?, :finite?, :infinite?, :integer?,
           :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 +138,33 @@ 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,
+          # `name` (the frozen-string accessor), `id2name` (alias of
+          # `to_s`), and `intern` (alias of `to_sym`) are pure reads of the
+          # symbol's text — siblings of the already-folded `to_s` / `to_sym`.
+          :name, :id2name, :intern
         ].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 +433,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 +461,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 +499,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 +550,21 @@ 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
-        # scalars; `foldable_constant_value?` rejects Array
+        # v0.0.7 — `Constant<String>#chars` / `bytes` / `codepoints` /
+        # `grapheme_clusters` / `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`;
+        # `grapheme_clusters` is the extended-grapheme sibling of `chars`.)
+        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :codepoints, :grapheme_clusters, :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 +594,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 +721,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 +1461,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 +1499,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

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

@@ -2,6 +2,7 @@
 
 require_relative "../../type"
 require_relative "singleton_folding"
+require_relative "member_shape_projection"
 
 module Rigor
   module Inference
@@ -30,6 +31,10 @@ module Rigor
       module DataFolding
         module_function
 
+        # The `[]` / `to_h` / `deconstruct` / `members` / `with` projections
+        # and the reader-redefinition guard are shared with {StructFolding}.
+        extend MemberShapeProjection
+
         # @return [Rigor::Type, nil] the folded result, or nil to defer.
         def try_dispatch(context)
           receiver = context.receiver
@@ -165,81 +170,12 @@ module Rigor
           when :deconstruct then instance_deconstruct(instance)
           when :deconstruct_keys then instance_deconstruct_keys(instance, args)
           when :members then instance_members(instance)
-          when :with then instance_with(instance, args)
+          when :with
+            instance_with(instance, args) do |members, class_name|
+              Type::Combinator.data_instance_of(members: members, class_name: class_name)
+            end
           end
         end
-
-        # A `Data.define` class body (the `class Point < Data.define(:x);
-        # def x; …; end; end` subclass body, or a `Const = Data.define(:x) do
-        # def x; …; end; end` block) can redefine a member's synthesised
-        # reader. When it does, `inst.x` runs that `def`, NOT the member, so
-        # folding the read to the member type would be unsound (a downstream
-        # FP). Both named forms register the override as a real `def` node
-        # under the class name, so an entry in the project def-node table is
-        # the discriminator (the synthesised reader has no def node). The
-        # value accessors `[]` / `to_h` / `deconstruct` bypass the reader and
-        # stay foldable, so this gate is on the bare member read only.
-        def reader_overridden?(instance, method_name, scope)
-          class_name = instance.class_name
-          return false if class_name.nil? || scope.nil?
-
-          !scope.user_def_for(class_name, method_name).nil?
-        end
-
-        def instance_index(instance, args)
-          return nil unless args.size == 1
-
-          arg = args.first
-          return nil unless arg.is_a?(Type::Constant)
-
-          key = arg.value
-          case key
-          when Symbol
-            instance.members[key]
-          when Integer
-            values = instance.members.values
-            idx = key.negative? ? key + values.size : key
-            values[idx] if idx && idx >= 0 && idx < values.size
-          end
-        end
-
-        def instance_to_h(instance)
-          Type::Combinator.hash_shape_of(instance.members.dup)
-        end
-
-        def instance_deconstruct(instance)
-          Type::Combinator.tuple_of(*instance.members.values)
-        end
-
-        # `deconstruct_keys(nil)` / `deconstruct_keys([:x])` both yield a
-        # subset of the member map; the conservative, always-correct answer
-        # is the full closed member shape.
-        def instance_deconstruct_keys(instance, args)
-          return nil unless args.size <= 1
-
-          Type::Combinator.hash_shape_of(instance.members.dup)
-        end
-
-        def instance_members(instance)
-          Type::Combinator.tuple_of(*instance.member_names.map { |name| Type::Combinator.constant_of(name) })
-        end
-
-        # `Data#with(x: 9)` returns a new frozen copy with the named members
-        # overridden. Only a closed keyword `HashShape` whose keys are a
-        # subset of the members folds; anything else defers (RBS resolves
-        # `with` to `self`, returning the unchanged instance type).
-        def instance_with(instance, args)
-          return instance if args.empty?
-          return nil unless args.size == 1
-
-          shape = args.first
-          return nil unless shape.is_a?(Type::HashShape) && shape.closed?
-          return nil unless shape.optional_keys.empty?
-          return nil unless shape.pairs.keys.all? { |key| instance.members.key?(key) }
-
-          merged = instance.members.merge(shape.pairs)
-          Type::Combinator.data_instance_of(members: merged, class_name: instance.class_name)
-        end
       end
     end
   end

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

@@ -54,11 +54,10 @@ module Rigor
       # *correctness-preservingly* proved" excludes Constants whose
       # value is host-specific.
       module FileFolding
-        # File class methods that the analyzer can fold *when the
-        # fold is platform-safe to perform*. Today every entry is
-        # platform-sensitive (every one observes `File::SEPARATOR`
-        # or `File::ALT_SEPARATOR`); the gate below requires the
-        # opt-in flag for any of them to fire.
+        # File class methods the analyzer can fold when the opt-in
+        # flag is set. Currently identical to PLATFORM_DEPENDENT_METHODS
+        # — separated for a future non-platform-sensitive tier that
+        # can fold without the opt-in flag.
         FILE_PURE_CLASS_METHODS = Set[
           :basename,
           :dirname,
@@ -72,8 +71,8 @@ module Rigor
         # Methods whose result depends on host directory-separator
         # semantics (`/` on POSIX, `/` AND `\` on Windows, drive
         # letters, UNC paths). Folding these would bake the
-        # analyzer-host's platform into the inferred type. The opt-
-        # in flag below controls whether to do it anyway.
+        # analyzer-host's platform into the inferred type. The opt-in
+        # flag below controls whether to do it anyway.
         PLATFORM_DEPENDENT_METHODS = Set[
           :basename, :dirname, :extname, :join, :split, :absolute_path?
         ].freeze

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

@@ -175,24 +175,18 @@ module Rigor
           type.is_a?(Type::Constant) && type.value.is_a?(Symbol)
         end
 
-        # Element-yielding Enumerable methods covered as a v0.0.5
-        # placeholder. RBS already binds the block parameter
-        # correctly for plain `Array[T]` / `Set[T]` / `Range[T]`
-        # receivers via generic substitution; this tier exists so
-        # Tuple- and HashShape-shaped receivers reach the block
-        # body with the precise per-position element union /
-        # `Tuple[K, V]` pair rather than the projected
+        # Element-yielding Enumerable methods covered as a placeholder.
+        # RBS already binds the block parameter correctly for plain
+        # `Array[T]` / `Set[T]` / `Range[T]` receivers via generic
+        # substitution; this tier exists so Tuple- and HashShape-shaped
+        # receivers reach the block body with the precise per-position
+        # element union / `Tuple[K, V]` pair rather than the projected
         # `Array[union]` / `Hash[K, V]` widening.
         #
-        # NOTE (v0.0.5): the per-method coverage here (group_by,
-        # partition, each_slice, each_cons) is intentionally
-        # narrow. The longer-term direction is to move
-        # Enumerable-aware projections into a plugin tier modelled
-        # after PHPStan's extension API (ADR-2). The placeholders
-        # below stay until the plugin surface is in place; once it
-        # ships, this dispatcher loses these arms and the
-        # equivalent rules move into a built-in plugin loaded at
-        # boot.
+        # NOTE: `Plugin::NodeRuleWalk` (ADR-52 WD4) is now in place as
+        # the intended migration target for these Enumerable projections.
+        # The four methods (group_by, partition, each_slice, each_cons)
+        # remain here pending that migration.
         def single_element_block_params(receiver)
           element = element_type_of(receiver)
           return nil if element.nil?

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

@@ -43,14 +43,21 @@ module Rigor
         private_constant :NUMERIC_CONSTRUCTORS
 
         # `Kernel#Integer(s)` predicate-aware refinement set
-        # (v0.1.1 Track 1 slice 2b). Both `decimal-int-string` and
-        # `numeric-string` describe digit-only ASCII strings, so
-        # `Integer(s)` is total over the carrier domain and the
-        # result is `>= 0`. The default `base: 10` invocation
-        # accepts the same shape `String#to_i` does for these
-        # predicates; the `Integer(s, base)` overload is left for
-        # a later slice.
-        INTEGER_REFINEMENT_PREDICATES = Set[:decimal_int, :numeric].freeze
+        # (v0.1.1 Track 1 slice 2b). `decimal-int-string` is the
+        # only string refinement whose every inhabitant `Integer(s)`
+        # parses without remainder, so the result is a plain
+        # `Integer` — but NOT `non-negative-int`: the predicate
+        # `/\A-?\d+\z/` admits a leading sign, so `"-7"` is a valid
+        # decimal-int-string and `Integer("-7") == -7 < 0`. The
+        # narrowing is total (every inhabitant parses) but not `>= 0`,
+        # so it lands on `universal_int`. `numeric-string` is
+        # deliberately NOT in this set at all: since it was widened to
+        # the full Ruby numeric-literal grammar (floats, hex, rational,
+        # imaginary, signs), `Integer(numeric_string)` would raise for
+        # a `"1.5"` / `"2i"` inhabitant — not even total — so it falls
+        # through to RBS `Integer`. The `Integer(s, base)` overload is
+        # left for a later slice.
+        INTEGER_REFINEMENT_PREDICATES = Set[:decimal_int].freeze
         private_constant :INTEGER_REFINEMENT_PREDICATES
 
         def try_dispatch(context)
@@ -70,7 +77,7 @@ module Rigor
         # paths, tried in order:
         #
         # 1. A `Refined[String, predicate]` argument whose predicate
-        #    is a digit-only carrier narrows to `non-negative-int`
+        #    is a total-parse carrier narrows to `universal_int`
         #    (see {try_integer_from_refinement}).
         # 2. A `Constant` String or Numeric argument — optionally
         #    with a `Constant[Integer]` base — runs the actual
@@ -120,9 +127,14 @@ module Rigor
         # `Kernel#Integer(s)` over a `Refined[String, predicate]`
         # whose predicate is in {INTEGER_REFINEMENT_PREDICATES}.
         # Mirrors the `String#to_i` projection in `ShapeDispatch`
-        # (v0.1.1 slice 2a) — the result is always
-        # `non-negative-int`. Returns nil for any other arg shape
-        # so the RBS tier handles the generic `Integer(arg)` case.
+        # (v0.1.1 slice 2a) — the result is `universal_int`, NOT
+        # `non-negative-int`: a decimal-int-string admits a leading
+        # sign (`"-7"`), so the parsed Integer can be negative. The
+        # carrier stays an `IntegerRange` (rather than declining to
+        # the RBS `Nominal[Integer]`) so downstream range narrowing
+        # still has a range to intersect. Returns nil for any other
+        # arg shape so the RBS tier handles the generic `Integer(arg)`
+        # case.
         def try_integer_from_refinement(args)
           return nil unless args.size == 1
 
@@ -133,7 +145,7 @@ module Rigor
           return nil unless base.is_a?(Type::Nominal) && base.class_name == "String"
           return nil unless INTEGER_REFINEMENT_PREDICATES.include?(arg.predicate_id)
 
-          Type::Combinator.non_negative_int
+          Type::Combinator.universal_int
         end
 
         def try_array(args)

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # The member-shape projections shared by {DataFolding} and
+      # {StructFolding}. A `DataInstance` and a `StructInstance` expose the
+      # same surface — an ordered `members` map, `member_names`, and a
+      # `class_name` — so the value projections off that surface
+      # (`[]` / `to_h` / `deconstruct` / `deconstruct_keys` / `members` /
+      # `with`) and the reader-redefinition guard are identical between the
+      # two folders. Only `#with`'s carrier constructor differs
+      # (`data_instance_of` vs `struct_instance_of`), so it takes a block
+      # that builds the new instance from the merged member map.
+      #
+      # Both folders `extend` this module so the projections resolve as
+      # their own module functions (matching their `module_function` style).
+      module MemberShapeProjection
+        # A Data/Struct subclass body can redefine a member's synthesised
+        # reader (`def x`); when it does, `inst.x` runs that `def`, not the
+        # member, so folding the read would be unsound. A real `def` node
+        # under the class name is the discriminator (the synthesised reader
+        # has none), so an entry in the project def-node table gates the
+        # bare member read off.
+        def reader_overridden?(instance, method_name, scope)
+          class_name = instance.class_name
+          return false if class_name.nil? || scope.nil?
+
+          !scope.user_def_for(class_name, method_name).nil?
+        end
+
+        def instance_index(instance, args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant)
+
+          key = arg.value
+          case key
+          when Symbol
+            instance.members[key]
+          when Integer
+            values = instance.members.values
+            idx = key.negative? ? key + values.size : key
+            values[idx] if idx && idx >= 0 && idx < values.size
+          end
+        end
+
+        def instance_to_h(instance)
+          Type::Combinator.hash_shape_of(instance.members.dup)
+        end
+
+        def instance_deconstruct(instance)
+          Type::Combinator.tuple_of(*instance.members.values)
+        end
+
+        # `deconstruct_keys(nil)` / `deconstruct_keys([:x])` both yield a
+        # subset of the member map; the conservative, always-correct answer
+        # is the full closed member shape.
+        def instance_deconstruct_keys(instance, args)
+          return nil unless args.size <= 1
+
+          Type::Combinator.hash_shape_of(instance.members.dup)
+        end
+
+        def instance_members(instance)
+          Type::Combinator.tuple_of(*instance.member_names.map { |name| Type::Combinator.constant_of(name) })
+        end
+
+        # `#with(x: 9)` returns a new copy with the named members
+        # overridden. Only a closed keyword `HashShape` whose keys are a
+        # subset of the members folds; anything else defers (RBS resolves
+        # `with` to `self`, returning the unchanged instance type). The
+        # carrier constructor differs per folder, so the caller supplies it
+        # as a block taking the merged member map and the class name.
+        def instance_with(instance, args)
+          return instance if args.empty?
+          return nil unless args.size == 1
+
+          shape = args.first
+          return nil unless shape.is_a?(Type::HashShape) && shape.closed?
+          return nil unless shape.optional_keys.empty?
+          return nil unless shape.pairs.keys.all? { |key| instance.members.key?(key) }
+
+          merged = instance.members.merge(shape.pairs)
+          yield(merged, instance.class_name)
+        end
+      end
+    end
+  end
+end

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

@@ -25,9 +25,7 @@ module Rigor
       #    so without this preference, an alias-typed overload like
       #    `Array#[](::int) -> Elem` would beat the strict
       #    `Array#[](Range) -> Array[Elem]?` overload for a Range
-      #    argument. (Surfaced during v0.1.1 self-analysis; see the
-      #    "Interface-strictness on overload selection" item in
-      #    `docs/ROADMAP.md`.)
+      #    argument.
       # 3. **Pass 2 — gradual fall-back.** If no fully strict overload
       #    matches, accept the first arity-and-gradual-accept match
       #    (the v0.1.1 behaviour). Alias / Interface / Intersection