rigortype 0.2.7 → 0.2.8

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

@@ -7,25 +7,19 @@ require_relative "member_shape_projection"
 module Rigor
   module Inference
     module MethodDispatcher
-      # ADR-48 — `Data.define` value folding. Three responsibilities, all
-      # gated on a fully-decidable shape and degrading to today's behaviour
-      # (no carrier / the `Data` nominal) the moment a premise is uncertain,
-      # so the tier is precision-additive and adds no false-positive
-      # surface:
+      # ADR-48 — `Data.define` value folding. Three responsibilities, all gated on a fully-decidable shape
+      # and degrading to today's behaviour (no carrier / the `Data` nominal) the moment a premise is
+      # uncertain, so the tier is precision-additive and adds no false-positive surface:
       #
-      # 1. `Data.define(:x, :y)` on a `Singleton[Data]` receiver with
-      #    literal-Symbol args and NO block -> `DataClass{members: [...]}`.
-      #    A block (`Data.define(:x) do ... end`) defers (slice 4 hardens
-      #    the block-body case); non-literal members (`Data.define(*names)`)
-      #    defer.
-      # 2. `.new` / `.[]` on a `DataClass` receiver -> a `DataInstance`
-      #    whose member map is built from the call's positional or keyword
-      #    arguments. An arity / key mismatch degrades to the `Data` (or the
+      # 1. `Data.define(:x, :y)` on a `Singleton[Data]` receiver with literal-Symbol args and NO block ->
+      #    `DataClass{members: [...]}`. A block (`Data.define(:x) do ... end`) defers (slice 4 hardens the
+      #    block-body case); non-literal members (`Data.define(*names)`) defer.
+      # 2. `.new` / `.[]` on a `DataClass` receiver -> a `DataInstance` whose member map is built from the
+      #    call's positional or keyword arguments. An arity / key mismatch degrades to the `Data` (or the
       #    tagged class) nominal rather than a wrong member map.
-      # 3. member reads + `[]` / `to_h` / `deconstruct` / `deconstruct_keys`
-      #    / `members` / `with` on a `DataInstance` receiver -> the precise
-      #    projected type. Unhandled methods return nil so the pipeline
-      #    projects the instance to its nominal through RbsDispatch.
+      # 3. member reads + `[]` / `to_h` / `deconstruct` / `deconstruct_keys` / `members` / `with` on a
+      #    `DataInstance` receiver -> the precise projected type. Unhandled methods return nil so the
+      #    pipeline projects the instance to its nominal through RbsDispatch.
       #
       # See docs/adr/48-data-struct-value-folding.md.
       module DataFolding
@@ -51,11 +45,10 @@ module Rigor
           end
         end
 
-        # A `Data.define` value object assigned to a constant (or a
-        # `class Point < Data.define(...)` subclass) is canonicalised by the
-        # engine to `Singleton[Point]`, not a `DataClass` — so its member
-        # layout is read from the project side-table the scope indexer built
-        # (`Scope#data_member_layout`) rather than from the receiver carrier.
+        # A `Data.define` value object assigned to a constant (or a `class Point < Data.define(...)`
+        # subclass) is canonicalised by the engine to `Singleton[Point]`, not a `DataClass` — so its member
+        # layout is read from the project side-table the scope indexer built (`Scope#data_member_layout`)
+        # rather than from the receiver carrier.
         def fold_named_new(singleton, context)
           scope = context.scope
           return nil if scope.nil?
@@ -79,8 +72,8 @@ module Rigor
           Type::Combinator.data_class_of(members: members)
         end
 
-        # The ordered Symbol member names, or nil when any argument is not
-        # a literal `Constant[Symbol]` (a splat or dynamic name).
+        # The ordered Symbol member names, or nil when any argument is not a literal `Constant[Symbol]` (a
+        # splat or dynamic name).
         def member_names_from_args(args)
           names = args.map do |arg|
             return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Symbol)
@@ -104,9 +97,8 @@ module Rigor
           Type::Combinator.data_instance_of(members: map, class_name: class_name)
         end
 
-        # Builds the member -> type map from the call's arguments, honouring
-        # the keyword vs positional distinction read off the call node. nil
-        # when the arguments cannot soundly populate every member.
+        # Builds the member -> type map from the call's arguments, honouring the keyword vs positional
+        # distinction read off the call node. nil when the arguments cannot soundly populate every member.
         def member_map_for_new(members, context)
           if keyword_new?(context)
             keyword_member_map(members, context.args)
@@ -115,10 +107,9 @@ module Rigor
           end
         end
 
-        # `Point.new(x: 1, y: 2)` arrives as a single trailing `HashShape`
-        # arg whose call node is a `KeywordHashNode`. Distinguishing it from
-        # a positional hash (`Point.new({x: 1})`, a `HashNode`) needs the
-        # call node, since both type to a `HashShape`.
+        # `Point.new(x: 1, y: 2)` arrives as a single trailing `HashShape` arg whose call node is a
+        # `KeywordHashNode`. Distinguishing it from a positional hash (`Point.new({x: 1})`, a `HashNode`)
+        # needs the call node, since both type to a `HashShape`.
         def keyword_new?(context)
           node = context.call_node
           return false if node.nil?
@@ -146,9 +137,8 @@ module Rigor
           members.zip(args).to_h
         end
 
-        # A `.new` whose arguments do not fold to a precise map still has a
-        # sound, more-precise-than-Dynamic answer: an instance of the
-        # tagged class (or the `Data` supertype).
+        # A `.new` whose arguments do not fold to a precise map still has a sound, more-precise-than-Dynamic
+        # answer: an instance of the tagged class (or the `Data` supertype).
         def degraded_instance(class_name)
           Type::Combinator.nominal_of(class_name || "Data")
         end

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

@@ -8,51 +8,36 @@ module Rigor
     module MethodDispatcher
       # IO / File support — the pure-path-manipulation tier.
       #
-      # File and IO carry a lot of side-effecting surface (filesystem
-      # reads, descriptor mutations, line iteration) the analyzer
-      # cannot fold. Several `File` class methods, however, are
-      # functions over their path-string arguments — they do NOT
-      # touch the filesystem and do NOT depend on the current
-      # working directory.
+      # File and IO carry a lot of side-effecting surface (filesystem reads, descriptor mutations, line iteration)
+      # the analyzer cannot fold. Several `File` class methods, however, are functions over their path-string
+      # arguments — they do NOT touch the filesystem and do NOT depend on the current working directory.
       #
-      # Folding them is platform-sensitive: every recognised method
-      # ([:basename, :dirname, :extname, :join, :split,
-      # :absolute_path?]) reads `File::SEPARATOR` /
-      # `File::ALT_SEPARATOR` and produces different answers on
-      # Windows vs POSIX hosts. The Ruby process running the
-      # analyzer hosts ONE platform; folding to a `Constant<String>`
-      # would silently bake that platform's answer into the
-      # analyzer's result and mis-report it on a host with a
+      # Folding them is platform-sensitive: every recognised method ([:basename, :dirname, :extname, :join, :split,
+      # :absolute_path?]) reads `File::SEPARATOR` / `File::ALT_SEPARATOR` and produces different answers on Windows
+      # vs POSIX hosts. The Ruby process running the analyzer hosts ONE platform; folding to a `Constant<String>`
+      # would silently bake that platform's answer into the analyzer's result and mis-report it on a host with a
       # different separator policy.
       #
-      # Default policy (`fold_platform_specific_paths == false`):
-      # decline the fold so the RBS tier answers with `Nominal[String]`
-      # / `Tuple[Nominal[String], Nominal[String]]` / `bool`. That is
-      # the platform-agnostic envelope — every concrete answer the
-      # method could legally return on any platform fits inside it.
-      # The future `non-empty-string` refinement carrier (see
-      # [imported-built-in-types.md](../../../../../docs/type-specification/imported-built-in-types.md))
-      # will tighten the basename/dirname/join cases further without
-      # leaking platform specifics; today we leave them at the
-      # nominal envelope.
+      # Default policy (`fold_platform_specific_paths == false`): decline the fold so the RBS tier answers with
+      # `Nominal[String]` / `Tuple[Nominal[String], Nominal[String]]` / `bool`. That is the platform-agnostic
+      # envelope — every concrete answer the method could legally return on any platform fits inside it. The future
+      # `non-empty-string` refinement carrier (see
+      # [imported-built-in-types.md](../../../../../docs/type-specification/imported-built-in-types.md)) will
+      # tighten the basename/dirname/join cases further without leaking platform specifics; today we leave them at
+      # the nominal envelope.
       #
-      # Opt-in policy (`fold_platform_specific_paths == true`):
-      # the analyzer trusts that its host platform matches the
-      # callers' deployment target and folds to a precise
-      # `Constant<String>`. Single-platform projects (most internal
-      # tooling, Rails apps deployed to Linux containers) can
-      # enable this in `.rigor.yml`:
+      # Opt-in policy (`fold_platform_specific_paths == true`): the analyzer trusts that its host platform matches
+      # the callers' deployment target and folds to a precise `Constant<String>`. Single-platform projects (most
+      # internal tooling, Rails apps deployed to Linux containers) can enable this in `.rigor.yml`:
       #
       #   fold_platform_specific_paths: true
       #
-      # The runner reads this on startup (`Rigor::Analysis::Runner`)
-      # and writes the flag here. Tests toggle the flag explicitly.
+      # The runner reads this on startup (`Rigor::Analysis::Runner`) and writes the flag here. Tests toggle the
+      # flag explicitly.
       #
-      # See [ADR-5 — robustness principle](../../../../../docs/adr/5-robustness-principle.md):
-      # the platform-agnostic default is clause-1 of the principle
-      # applied with the constraint that "as strict as can be
-      # *correctness-preservingly* proved" excludes Constants whose
-      # value is host-specific.
+      # See [ADR-5 — robustness principle](../../../../../docs/adr/5-robustness-principle.md): the
+      # platform-agnostic default is clause-1 of the principle applied with the constraint that "as strict as can
+      # be *correctness-preservingly* proved" excludes Constants whose value is host-specific.
       module FileFolding
         # File class methods the analyzer can fold when the opt-in
         # flag is set. Currently identical to PLATFORM_DEPENDENT_METHODS

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

@@ -8,26 +8,20 @@ module Rigor
     module MethodDispatcher
       # Iterator-style block-parameter typing.
       #
-      # Sits ahead of `RbsDispatch.block_param_types` so the precise
-      # integer bounds for `Integer#times` / `Integer#upto` /
-      # `Integer#downto` reach the block body's parameter binder.
-      # Without this tier the RBS signature for `Integer#times`
-      # widens the index to `Nominal[Integer]`, dropping every
-      # bound the receiver carries.
+      # Sits ahead of `RbsDispatch.block_param_types` so the precise integer bounds for `Integer#times` /
+      # `Integer#upto` / `Integer#downto` reach the block body's parameter binder. Without this tier the
+      # RBS signature for `Integer#times` widens the index to `Nominal[Integer]`, dropping every bound the
+      # receiver carries.
       #
       # Each rule mirrors Ruby's actual iteration semantics:
       #
-      # - `n.times { |i| … }` yields `i ∈ [0, n-1]` when `n > 0`,
-      #   nothing otherwise. The block-param type is therefore
-      #   `int<0, n-1>` for a `Constant<Integer>` receiver,
-      #   `int<0, upper-1>` for a finite `IntegerRange`, and
-      #   `non_negative_int` for any unbounded-above shape.
-      # - `a.upto(b) { |i| … }` yields `i ∈ [a, b]` when `a <= b`.
-      #   Lower bound from the receiver, upper bound from the
-      #   argument.
-      # - `a.downto(b) { |i| … }` yields the same domain `[b, a]`,
-      #   just iterated in reverse. Lower bound from the
-      #   argument, upper bound from the receiver.
+      # - `n.times { |i| … }` yields `i ∈ [0, n-1]` when `n > 0`, nothing otherwise. The block-param type is
+      #   therefore `int<0, n-1>` for a `Constant<Integer>` receiver, `int<0, upper-1>` for a finite
+      #   `IntegerRange`, and `non_negative_int` for any unbounded-above shape.
+      # - `a.upto(b) { |i| … }` yields `i ∈ [a, b]` when `a <= b`. Lower bound from the receiver, upper
+      #   bound from the argument.
+      # - `a.downto(b) { |i| … }` yields the same domain `[b, a]`, just iterated in reverse. Lower bound
+      #   from the argument, upper bound from the receiver.
       module IteratorDispatch
         module_function
 
@@ -50,15 +44,12 @@ module Rigor
           end
         end
 
-        # `Class.new { |c| … }` and `Class.new(Parent) { |c| … }`
-        # — the block parameter is the freshly-created anonymous
-        # class, statically representable as the parent's singleton
-        # type (the new class inherits every singleton method the
-        # parent exposes, which is what callers use this form to
-        # configure: `c.table_name = …`, `c.attribute :foo`, etc.).
-        # No parent → `singleton(Object)`. RBS would otherwise widen
-        # the block param to bare `Nominal[Class]`, dropping access
-        # to the parent's class-side surface.
+        # `Class.new { |c| … }` and `Class.new(Parent) { |c| … }` — the block parameter is the
+        # freshly-created anonymous class, statically representable as the parent's singleton type (the new
+        # class inherits every singleton method the parent exposes, which is what callers use this form to
+        # configure: `c.table_name = …`, `c.attribute :foo`, etc.). No parent → `singleton(Object)`. RBS
+        # would otherwise widen the block param to bare `Nominal[Class]`, dropping access to the parent's
+        # class-side surface.
         def class_new_block_params(receiver, args)
           return nil unless class_metaclass_receiver?(receiver)
 
@@ -95,24 +86,20 @@ module Rigor
           [build_index_range(lower_bound_of(end_arg), upper_bound_of(receiver))]
         end
 
-        # Generalised iterator: every Enumerable-shaped collection
-        # in v0.0.4 yields `(element, index)` where the index is
-        # always `non-negative-int`. The element comes from the
-        # receiver's shape:
+        # Generalised iterator: every Enumerable-shaped collection in v0.0.4 yields `(element, index)` where
+        # the index is always `non-negative-int`. The element comes from the receiver's shape:
         #
         # - `Array[T]` / `Set[T]` / `Range[T]`              → T
         # - `Tuple[A, B, C]`                                → A | B | C
-        #   (empty tuple cannot iterate, but we conservatively
-        #   fall through to RBS so a missing rule never throws)
+        #   (empty tuple cannot iterate, but we conservatively fall through to RBS so a missing rule never
+        #   throws)
         # - `Hash[K, V]` / `HashShape{...}`                 → Tuple[K, V]
         #   (Ruby yields `[key, value]` pairs as the element)
         # - `Constant<Array>` / `Constant<Range>` / `Constant<Set>`
         #                                                   → corresponding Constant element
         #
-        # Receivers we cannot project (Top, Dynamic, unknown
-        # nominals, IO, …) decline so the RBS tier still answers
-        # — its element type is correct, only the index would
-        # widen to plain Integer.
+        # Receivers we cannot project (Top, Dynamic, unknown nominals, IO, …) decline so the RBS tier still
+        # answers — its element type is correct, only the index would widen to plain Integer.
         def each_with_index_block_params(receiver)
           element = element_type_of(receiver)
           return nil if element.nil?
@@ -120,13 +107,11 @@ module Rigor
           [element, Type::Combinator.non_negative_int]
         end
 
-        # `each_with_object(memo) { |elem, memo_inner| … }` yields
-        # `(element, memo)` where `memo` is the second argument's
-        # type (passed by reference and threaded across iterations
-        # at runtime — Rigor reflects that by binding the block's
-        # second parameter to whatever the call site supplied).
-        # When the call has no memo argument the dispatcher
-        # declines so the user's RBS / overload selector decides.
+        # `each_with_object(memo) { |elem, memo_inner| … }` yields `(element, memo)` where `memo` is the
+        # second argument's type (passed by reference and threaded across iterations at runtime — Rigor
+        # reflects that by binding the block's second parameter to whatever the call site supplied). When
+        # the call has no memo argument the dispatcher declines so the user's RBS / overload selector
+        # decides.
         def each_with_object_block_params(receiver, memo_arg)
           return nil if memo_arg.nil?
 
@@ -136,21 +121,15 @@ module Rigor
           [element, memo_arg]
         end
 
-        # `inject(seed) { |memo, elem| … }` and `reduce` accept
-        # three call shapes:
+        # `inject(seed) { |memo, elem| … }` and `reduce` accept three call shapes:
         #
-        # - `(seed) { |memo, elem| … }` — block params `[seed, element]`.
-        #   The memo's static type is the seed's; we cannot prove the
-        #   block return type here without round-tripping through the
-        #   block analyser, so the binding is the seed's type and
-        #   downstream inference widens as needed.
-        # - `() { |memo, elem| … }` — the first iteration uses the
-        #   first element as the memo, so `[element, element]` is the
-        #   sound binding.
-        # - `(seed, :sym)` / `(:sym)` — Symbol method-name forms have
-        #   no block. `inject` with a Symbol final arg is recognised
-        #   and declined (returns nil) so the dispatcher does not
-        #   pretend a block existed.
+        # - `(seed) { |memo, elem| … }` — block params `[seed, element]`. The memo's static type is the
+        #   seed's; we cannot prove the block return type here without round-tripping through the block
+        #   analyser, so the binding is the seed's type and downstream inference widens as needed.
+        # - `() { |memo, elem| … }` — the first iteration uses the first element as the memo, so
+        #   `[element, element]` is the sound binding.
+        # - `(seed, :sym)` / `(:sym)` — Symbol method-name forms have no block. `inject` with a Symbol final
+        #   arg is recognised and declined (returns nil) so the dispatcher does not pretend a block existed.
         def inject_block_params(receiver, args)
           element = element_type_of(receiver)
           return nil if element.nil?
@@ -175,18 +154,15 @@ module Rigor
           type.is_a?(Type::Constant) && type.value.is_a?(Symbol)
         end
 
-        # 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
+        # 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: `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.
+        # 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?
@@ -194,11 +170,9 @@ module Rigor
           [element]
         end
 
-        # `each_slice(n) { |slice| … }` and `each_cons(n) { |window| … }`
-        # both yield an `Array[element]` once per iteration. The
-        # tier ignores the slice-size argument (a Constant<Integer>
-        # `n` could in principle bound the slice's length, but a
-        # tighter Tuple-of-`n` carrier is reserved for the plugin
+        # `each_slice(n) { |slice| … }` and `each_cons(n) { |window| … }` both yield an `Array[element]`
+        # once per iteration. The tier ignores the slice-size argument (a Constant<Integer> `n` could in
+        # principle bound the slice's length, but a tighter Tuple-of-`n` carrier is reserved for the plugin
         # tier per the NOTE above).
         def slice_block_params(receiver)
           element = element_type_of(receiver)
@@ -278,14 +252,12 @@ module Rigor
             return build_index_range(beg, upper)
           end
 
-          # Mixed / non-integer ranges decline: the dispatcher
-          # falls through to RBS's element-type answer.
+          # Mixed / non-integer ranges decline: the dispatcher falls through to RBS's element-type answer.
           nil
         end
 
-        # `Constant<Integer>`, `IntegerRange`, and `Nominal[Integer]`
-        # all participate. Non-integer types (Float, String, …) and
-        # `Top`/`Dynamic` decline so the RBS tier answers.
+        # `Constant<Integer>`, `IntegerRange`, and `Nominal[Integer]` all participate. Non-integer types
+        # (Float, String, …) and `Top`/`Dynamic` decline so the RBS tier answers.
         def integer_rooted?(type)
           case type
           when Type::Constant then type.value.is_a?(Integer)
@@ -311,10 +283,9 @@ module Rigor
           end
         end
 
-        # Builds a `Constant`/`IntegerRange` from possibly-symbolic
-        # bounds. Vacuous ranges (lower > upper, indicating the
-        # iterator does not fire) collapse to `non_negative_int` so
-        # the body still type-checks against a sensible binding.
+        # Builds a `Constant`/`IntegerRange` from possibly-symbolic bounds. Vacuous ranges (lower > upper,
+        # indicating the iterator does not fire) collapse to `non_negative_int` so the body still
+        # type-checks against a sensible binding.
         def build_index_range(lower, upper)
           return Type::Combinator.non_negative_int if vacuous_range?(lower, upper)
           return Type::Combinator.constant_of(lower) if lower.is_a?(Integer) && lower == upper

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

@@ -5,15 +5,13 @@ require_relative "../../type"
 module Rigor
   module Inference
     module MethodDispatcher
-      # Kernel intrinsic shape-folding — precision tier for the
-      # `Kernel` module-functions whose return type is a function
-      # of the argument's *shape*, not just its class.
+      # Kernel intrinsic shape-folding — precision tier for the `Kernel` module-functions whose return type
+      # is a function of the argument's *shape*, not just its class.
       #
-      # Today the only catalogued intrinsic is `Kernel#Array`. The
-      # default RBS sig is `Array(untyped) -> Array[untyped]`, which
-      # collapses to `Array[Dynamic[top]]` for every caller. This
-      # tier short-circuits with a precise answer when the argument's
-      # type lattice tells us what the result element type MUST be:
+      # Today the only catalogued intrinsic is `Kernel#Array`. The default RBS sig is
+      # `Array(untyped) -> Array[untyped]`, which collapses to `Array[Dynamic[top]]` for every caller. This
+      # tier short-circuits with a precise answer when the argument's type lattice tells us what the result
+      # element type MUST be:
       #
       #   Array(Constant[nil])         -> Array[bot]      # `[]`
       #   Array(Nominal["Array",[E]])  -> Array[E]        # already an Array
@@ -21,20 +19,17 @@ module Rigor
       #   Array(Union[A,B,…])          -> distribute, then unify
       #   Array(other Nominal[T])      -> Array[Nominal[T]]
       #
-      # For receiver shapes we cannot prove (`Top`, `Dynamic`, …)
-      # the tier returns nil and the RBS tier answers with the
-      # generic `Array[untyped]` envelope.
+      # For receiver shapes we cannot prove (`Top`, `Dynamic`, …) the tier returns nil and the RBS tier
+      # answers with the generic `Array[untyped]` envelope.
       #
-      # See `docs/type-specification/value-lattice.md` for the
-      # union-distribution contract this tier mirrors.
+      # See `docs/type-specification/value-lattice.md` for the union-distribution contract this tier
+      # mirrors.
       module KernelDispatch
         module_function
 
-        # `Kernel#Rational` / `Kernel#Complex` constructor folds.
-        # When every argument is a `Type::Constant` whose value is
-        # numeric, we can run the actual Ruby constructor and lift
-        # the result into a `Constant<Rational>` / `Constant<Complex>`.
-        # The factory accepts the same shapes as Ruby:
+        # `Kernel#Rational` / `Kernel#Complex` constructor folds. When every argument is a `Type::Constant`
+        # whose value is numeric, we can run the actual Ruby constructor and lift the result into a
+        # `Constant<Rational>` / `Constant<Complex>`. The factory accepts the same shapes as Ruby:
         # `Rational(a)`, `Rational(a, b)`, `Complex(a)`, `Complex(a, b)`.
         NUMERIC_CONSTRUCTORS = Ractor.make_shareable({
                                                        Rational: Ractor.make_shareable(->(*args) { Rational(*args) }),
@@ -42,21 +37,15 @@ module Rigor
                                                      })
         private_constant :NUMERIC_CONSTRUCTORS
 
-        # `Kernel#Integer(s)` predicate-aware refinement set
-        # (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.
+        # `Kernel#Integer(s)` predicate-aware refinement set (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
 
@@ -73,16 +62,12 @@ module Rigor
           nil
         end
 
-        # `Kernel#Integer(arg)` / `Integer(arg, base)`. Two folding
-        # paths, tried in order:
+        # `Kernel#Integer(arg)` / `Integer(arg, base)`. Two folding paths, tried in order:
         #
-        # 1. A `Refined[String, predicate]` argument whose predicate
-        #    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
-        #    `Integer()` conversion and lifts the result to
-        #    `Constant[Integer]`.
+        # 1. A `Refined[String, predicate]` argument whose predicate 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 `Integer()` conversion and lifts the result to `Constant[Integer]`.
         def try_integer(args)
           refined = try_integer_from_refinement(args)
           return refined if refined
@@ -90,10 +75,9 @@ module Rigor
           try_integer_constant(args)
         end
 
-        # Constant-folding path for `Integer()`. A non-parseable
-        # string raises `ArgumentError` (or `TypeError` for a base
-        # against a non-string) at fold time; the handler declines
-        # so the RBS tier answers with the widened `Integer`.
+        # Constant-folding path for `Integer()`. A non-parseable string raises `ArgumentError` (or
+        # `TypeError` for a base against a non-string) at fold time; the handler declines so the RBS tier
+        # answers with the widened `Integer`.
         def try_integer_constant(args)
           return nil unless [1, 2].include?(args.size)
           return nil unless args.all?(Type::Constant)
@@ -107,9 +91,8 @@ module Rigor
           nil
         end
 
-        # `Kernel#Float(arg)` — folds a `Constant` String or Numeric
-        # argument to `Constant[Float]`. A non-parseable string
-        # raises `ArgumentError` at fold time; the handler declines.
+        # `Kernel#Float(arg)` — folds a `Constant` String or Numeric argument to `Constant[Float]`. A
+        # non-parseable string raises `ArgumentError` at fold time; the handler declines.
         def try_float(args)
           return nil unless args.size == 1
 
@@ -124,17 +107,13 @@ module Rigor
           nil
         end
 
-        # `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 `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.
+        # `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 `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
 
@@ -157,11 +136,9 @@ module Rigor
           Type::Combinator.nominal_of("Array", type_args: [element])
         end
 
-        # `Rational(int)` / `Rational(num, den)` and `Complex(re)`
-        # / `Complex(re, im)` fold when every arg is a numeric
-        # Constant. The actual Ruby constructor runs at fold time
-        # (host-side), so the result respects Ruby's normalisation
-        # (`Rational(2, 4)` → `Rational(1, 2)`).
+        # `Rational(int)` / `Rational(num, den)` and `Complex(re)` / `Complex(re, im)` fold when every arg
+        # is a numeric Constant. The actual Ruby constructor runs at fold time (host-side), so the result
+        # respects Ruby's normalisation (`Rational(2, 4)` → `Rational(1, 2)`).
         def try_numeric_constructor(method_name, args)
           return nil unless [1, 2].include?(args.size)
           return nil unless args.all? { |arg| numeric_constant?(arg) }
@@ -181,21 +158,17 @@ module Rigor
               type.value.is_a?(Complex))
         end
 
-        # Computes the element type the argument contributes to the
-        # `Array(arg)` result, mirroring Ruby's coercion contract:
+        # Computes the element type the argument contributes to the `Array(arg)` result, mirroring Ruby's
+        # coercion contract:
         #
-        # - `nil` becomes `[]` (element type Bot — the empty array
-        #   contributes no inhabitants).
-        # - An existing `Array[E]` is returned as-is, so its element
-        #   type is `E`.
-        # - A `Tuple[T1, T2, …]` is materialised as `Array[T1|T2|…]`
-        #   (every tuple inhabitant is a tuple, hence Array-like).
-        # - Any other value `v` becomes `[v]`, so the element type
-        #   is the value's own type.
+        # - `nil` becomes `[]` (element type Bot — the empty array contributes no inhabitants).
+        # - An existing `Array[E]` is returned as-is, so its element type is `E`.
+        # - A `Tuple[T1, T2, …]` is materialised as `Array[T1|T2|…]` (every tuple inhabitant is a tuple,
+        #   hence Array-like).
+        # - Any other value `v` becomes `[v]`, so the element type is the value's own type.
         #
-        # Returns nil for receiver shapes the tier cannot prove
-        # (Top, Dynamic, Bot in pre-coercion position) so the
-        # caller falls back to the RBS-tier envelope.
+        # Returns nil for receiver shapes the tier cannot prove (Top, Dynamic, Bot in pre-coercion position)
+        # so the caller falls back to the RBS-tier envelope.
         def element_type_of(type)
           case type
           when Type::Union