rigortype 0.2.7 → 0.2.8

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

@@ -5,76 +5,55 @@ require_relative "../../type"
 module Rigor
   module Inference
     module MethodDispatcher
-      # Dispatcher tier that lifts string-composition results into
-      # the `literal-string` carrier when every operand is itself
-      # literal-bearing. Sits between {ConstantFolding} (which
-      # handles all-Constant cases) and {ShapeDispatch}; runs for:
+      # Dispatcher tier that lifts string-composition results into the `literal-string` carrier when every
+      # operand is itself literal-bearing. Sits between {ConstantFolding} (which handles all-Constant cases)
+      # and {ShapeDispatch}; runs for:
       #
-      # - `String#+` / `String#*` / `String#<<` / `String#concat`
-      #   on string-typed receivers whose inputs the
-      #   ConstantFolding tier could not fold to a precise
-      #   `Constant<String>` (e.g. one operand is `literal-string`
-      #   rather than `Constant<String>`, or the multiplication
-      #   exceeds the constant-fold size cap).
-      # - `Array#join` on `Tuple[…]` receivers whose every element
-      #   plus the separator argument (when given) is
-      #   literal-bearing.
-      # - `Kernel#format` / `Kernel#sprintf` (any receiver) and
-      #   `String#%` (literal-bearing receiver) when every value
-      #   argument is literal-bearing or a Type::Constant of any
-      #   value.
+      # - `String#+` / `String#*` / `String#<<` / `String#concat` on string-typed receivers whose inputs
+      #   the ConstantFolding tier could not fold to a precise `Constant<String>` (e.g. one operand is
+      #   `literal-string` rather than `Constant<String>`, or the multiplication exceeds the constant-fold
+      #   size cap).
+      # - `Array#join` on `Tuple[…]` receivers whose every element plus the separator argument (when given)
+      #   is literal-bearing.
+      # - `Kernel#format` / `Kernel#sprintf` (any receiver) and `String#%` (literal-bearing receiver) when
+      #   every value argument is literal-bearing or a Type::Constant of any value.
       #
       # Result rule:
       #
       # - `+`, `<<`, `concat`: receiver and argument MUST both be
-      #   `Type::Combinator.literal_string_compatible?`. The result
-      #   is `literal-string`. `<<` and `concat` mutate the
-      #   receiver at runtime; the analyzer does not track that
-      #   mutation against the local's binding, but the call's
-      #   *return value* is the receiver itself, and the receiver
-      #   stays literal-bearing because every appended slice was
-      #   literal-bearing too.
-      # - `*`: receiver MUST be literal-bearing; argument MUST be
-      #   integer-typed. The result is `literal-string`.
-      # - `join`: receiver MUST be `Tuple[…]` with every element
-      #   literal-string-compatible; the optional separator
-      #   argument MUST also be literal-string-compatible.
-      #   Result: `literal-string`. Empty `Tuple[]` lifts too —
-      #   `[].join` is the empty string at runtime, which is
-      #   literal-bearing trivially.
+      #   `Type::Combinator.literal_string_compatible?`. The result is `literal-string`. `<<` and `concat`
+      #   mutate the receiver at runtime; the analyzer does not track that mutation against the local's
+      #   binding, but the call's *return value* is the receiver itself, and the receiver stays
+      #   literal-bearing because every appended slice was literal-bearing too.
+      # - `*`: receiver MUST be literal-bearing; argument MUST be integer-typed. The result is
+      #   `literal-string`.
+      # - `join`: receiver MUST be `Tuple[…]` with every element literal-string-compatible; the optional
+      #   separator argument MUST also be literal-string-compatible. Result: `literal-string`. Empty
+      #   `Tuple[]` lifts too — `[].join` is the empty string at runtime, which is literal-bearing
+      #   trivially.
       #
-      # Other receiver / argument shapes decline so the next tier
-      # (ShapeDispatch / FileFolding / RbsDispatch) takes over and
-      # the call site widens to the RBS-declared `Nominal[String]`
-      # as before.
+      # Other receiver / argument shapes decline so the next tier (ShapeDispatch / FileFolding /
+      # RbsDispatch) takes over and the call site widens to the RBS-declared `Nominal[String]` as before.
       module LiteralStringFolding
         module_function
 
         CONCAT_METHODS = %i[+ << concat].freeze
         FORMAT_METHODS = %i[format sprintf].freeze
-        # v0.1.1 Track 1 slice 5a — methods that, called with no
-        # arguments on a literal-bearing receiver, return a value
-        # that is also literal-bearing. `#strip` / `#lstrip` /
-        # `#rstrip` / `#chomp` (no-arg) / `#chop` strip a known
-        # subset of characters from the ends, so the survivors
-        # are always a substring of an already-literal value.
-        # `#scrub` (no-arg) replaces invalid bytes; a literal-string
-        # value comes from source code and is always valid UTF-8,
-        # so the result is identical to the receiver. None of
-        # these preserve `non-empty-string`-ness (e.g. `"   ".strip
-        # == ""`); the carrier collapses from `non-empty-literal-string`
-        # down to plain `literal-string`.
+        # v0.1.1 Track 1 slice 5a — methods that, called with no arguments on a literal-bearing receiver,
+        # return a value that is also literal-bearing. `#strip` / `#lstrip` / `#rstrip` / `#chomp` (no-arg)
+        # / `#chop` strip a known subset of characters from the ends, so the survivors are always a
+        # substring of an already-literal value. `#scrub` (no-arg) replaces invalid bytes; a literal-string
+        # value comes from source code and is always valid UTF-8, so the result is identical to the
+        # receiver. None of these preserve `non-empty-string`-ness (e.g. `"   ".strip == ""`); the carrier
+        # collapses from `non-empty-literal-string` down to plain `literal-string`.
         LITERAL_PRESERVING_METHODS = %i[strip lstrip rstrip chomp chop scrub].freeze
-        # Methods that preserve literal-bearing AND non-empty-string-ness.
-        # Unlike `LITERAL_PRESERVING_METHODS` (strip/chomp/etc.) these do
-        # not reduce the string — they transform characters without
-        # removing any, so a non-empty receiver stays non-empty.
+        # Methods that preserve literal-bearing AND non-empty-string-ness. Unlike `LITERAL_PRESERVING_METHODS`
+        # (strip/chomp/etc.) these do not reduce the string — they transform characters without removing
+        # any, so a non-empty receiver stays non-empty.
         NON_EMPTY_LITERAL_PRESERVING_METHODS = %i[upcase downcase capitalize swapcase reverse].freeze
-        # v0.1.1 Track 1 slice 5c — width-padding methods. `center`
-        # / `ljust` / `rjust` take a `width` Integer plus an
-        # optional literal padding `String`. When the receiver
-        # and the (default or supplied) padding are both
-        # literal-bearing, the result is literal-bearing too.
+        # v0.1.1 Track 1 slice 5c — width-padding methods. `center` / `ljust` / `rjust` take a `width`
+        # Integer plus an optional literal padding `String`. When the receiver and the (default or
+        # supplied) padding are both literal-bearing, the result is literal-bearing too.
         WIDTH_PADDING_METHODS = %i[center ljust rjust].freeze
         private_constant :CONCAT_METHODS, :FORMAT_METHODS,
                          :LITERAL_PRESERVING_METHODS, :NON_EMPTY_LITERAL_PRESERVING_METHODS,
@@ -106,15 +85,11 @@ module Rigor
           nil
         end
 
-        # `String#center` / `#ljust` / `#rjust` — first argument is
-        # the target width (Integer-typed), optional second
-        # argument is the padding string (must be literal-bearing
-        # for the result to stay literal). The default padding
-        # (a space) is always literal so the no-second-arg form
-        # passes through. Width is allowed to be any Integer
-        # because Ruby's runtime accepts negative widths and
-        # widths smaller than the receiver's length without
-        # raising.
+        # `String#center` / `#ljust` / `#rjust` — first argument is the target width (Integer-typed),
+        # optional second argument is the padding string (must be literal-bearing for the result to stay
+        # literal). The default padding (a space) is always literal so the no-second-arg form passes
+        # through. Width is allowed to be any Integer because Ruby's runtime accepts negative widths and
+        # widths smaller than the receiver's length without raising.
         def fold_width_pad(args)
           return nil unless [1, 2].include?(args.size)
           return nil unless integer_typed?(args[0])
@@ -146,8 +121,8 @@ module Rigor
           Type::Combinator.literal_string
         end
 
-        # Returns `non_empty_literal_string` when the receiver is provably
-        # non-empty; otherwise collapses to plain `literal_string`.
+        # Returns `non_empty_literal_string` when the receiver is provably non-empty; otherwise collapses
+        # to plain `literal_string`.
         def non_empty_literal_result(receiver)
           if Type::Combinator.non_empty_string_compatible?(receiver)
             Type::Combinator.non_empty_literal_string
@@ -156,12 +131,10 @@ module Rigor
           end
         end
 
-        # `[lit, lit].join(sep)` — receiver must be a Tuple
-        # whose every element is literal-bearing; separator
-        # (when given) must be literal-bearing too. Multi-arg
-        # forms / `Array#join(*args)` splat shapes don't reach
-        # here because the dispatcher only routes through this
-        # tier when the call resolves to a single named method.
+        # `[lit, lit].join(sep)` — receiver must be a Tuple whose every element is literal-bearing;
+        # separator (when given) must be literal-bearing too. Multi-arg forms / `Array#join(*args)` splat
+        # shapes don't reach here because the dispatcher only routes through this tier when the call
+        # resolves to a single named method.
         def fold_array_join(receiver, args)
           return nil unless receiver.is_a?(Type::Tuple)
           return nil unless receiver.elements.all? { |el| Type::Combinator.literal_string_compatible?(el) }
@@ -171,15 +144,11 @@ module Rigor
           Type::Combinator.literal_string
         end
 
-        # `format("hello %s", lit)` / `sprintf(...)` — template
-        # plus every value argument must be literal-bearing
-        # ({Type::Combinator.literal_string_compatible?}) or a
-        # `Type::Constant` of any value (Constants are always
-        # provably literal). The template arg specifically must
-        # be literal-bearing — a Constant<Integer> first arg
-        # would not be a valid format template, so the
-        # `Type::Constant` allowance applies only to subsequent
-        # value args.
+        # `format("hello %s", lit)` / `sprintf(...)` — template plus every value argument must be
+        # literal-bearing ({Type::Combinator.literal_string_compatible?}) or a `Type::Constant` of any
+        # value (Constants are always provably literal). The template arg specifically must be
+        # literal-bearing — a Constant<Integer> first arg would not be a valid format template, so the
+        # `Type::Constant` allowance applies only to subsequent value args.
         def fold_format(args)
           return nil if args.empty?
           return nil unless Type::Combinator.literal_string_compatible?(args.first)
@@ -188,18 +157,14 @@ module Rigor
           Type::Combinator.literal_string
         end
 
-        # `"foo %s" % "x"` / `"foo %s" % ["x", "y"]` — receiver
-        # is the template (already verified literal-bearing by
-        # the caller); arg is either:
+        # `"foo %s" % "x"` / `"foo %s" % ["x", "y"]` — receiver is the template (already verified
+        # literal-bearing by the caller); arg is either:
         #
         # - a single literal-bearing string / Constant value, or
-        # - a Tuple whose every element is literal-bearing or a
-        #   Constant.
+        # - a Tuple whose every element is literal-bearing or a Constant.
         #
-        # Hash-form `%` (e.g. `"%{name}" % {name: "x"}`) is not
-        # yet folded — the analyzer's HashShape carrier could
-        # support this, but the v0.0.x catalogue declines and
-        # widens to Nominal[String].
+        # Hash-form `%` (e.g. `"%{name}" % {name: "x"}`) is not yet folded — the analyzer's HashShape
+        # carrier could support this, but the v0.0.x catalogue declines and widens to Nominal[String].
         def fold_string_percent(args)
           return nil unless args.size == 1
 
@@ -228,11 +193,9 @@ module Rigor
           end
         end
 
-        # `String#*` raises ArgumentError on a negative multiplier, so a
-        # `Constant<-1>` argument is not a valid lift target. Decline so
-        # the call site keeps the existing nil-result behaviour rather
-        # than promising a `literal-string` value that could never
-        # exist at runtime.
+        # `String#*` raises ArgumentError on a negative multiplier, so a `Constant<-1>` argument is not a
+        # valid lift target. Decline so the call site keeps the existing nil-result behaviour rather than
+        # promising a `literal-string` value that could never exist at runtime.
         def known_negative_integer?(type)
           type.is_a?(Type::Constant) && type.value.is_a?(Integer) && type.value.negative?
         end

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

@@ -6,43 +6,34 @@ require_relative "singleton_folding"
 module Rigor
   module Inference
     module MethodDispatcher
-      # Folds `Math` module-function calls on statically known numeric
-      # constants.
+      # Folds `Math` module-function calls on statically known numeric constants.
       #
-      # `Math` is a pure, side-effect-free module whose functions are
-      # deterministic over their inputs — the same number always
-      # produces the same result. When every relevant argument is a
-      # `Constant` carrying a `Numeric` value, the analyzer evaluates
-      # the call at inference time and returns the concrete result.
+      # `Math` is a pure, side-effect-free module whose functions are deterministic over their inputs — the
+      # same number always produces the same result. When every relevant argument is a `Constant` carrying
+      # a `Numeric` value, the analyzer evaluates the call at inference time and returns the concrete
+      # result.
       #
       # === Supported methods
       #
-      # * Single-argument transcendental functions (`sqrt`, `cbrt`,
-      #   `exp`, `log2`, `log10`, `log1p`, `expm1`, `sin`, `cos`,
-      #   `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`,
-      #   `asinh`, `acosh`, `atanh`, `erf`, `erfc`, `gamma`) — return
-      #   `Constant[Float]`.
+      # * Single-argument transcendental functions (`sqrt`, `cbrt`, `exp`, `log2`, `log10`, `log1p`,
+      #   `expm1`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`,
+      #   `atanh`, `erf`, `erfc`, `gamma`) — return `Constant[Float]`.
       #
-      # * Two-argument functions (`atan2`, `hypot`, `ldexp`) — return
-      #   `Constant[Float]`.
+      # * Two-argument functions (`atan2`, `hypot`, `ldexp`) — return `Constant[Float]`.
       #
-      # * `log(x)` / `log(x, base)` — variadic; folds the 1- and
-      #   2-argument forms to `Constant[Float]`.
+      # * `log(x)` / `log(x, base)` — variadic; folds the 1- and 2-argument forms to `Constant[Float]`.
       #
-      # * `frexp(x)` / `lgamma(x)` — return a two-element array, lifted
-      #   to `Tuple[Constant[Float], Constant[Integer]]`.
+      # * `frexp(x)` / `lgamma(x)` — return a two-element array, lifted to
+      #   `Tuple[Constant[Float], Constant[Integer]]`.
       #
       # === Non-constant / unsupported cases
       #
-      # Any call where the receiver is not `Singleton[Math]`, an
-      # argument is not a numeric `Constant`, the method is not in the
-      # supported set, or the Ruby call raises `Math::DomainError` /
-      # `RangeError` (domain-error inputs like `Math.sqrt(-1)`) returns
-      # `nil`, deferring to the next dispatcher tier.
+      # Any call where the receiver is not `Singleton[Math]`, an argument is not a numeric `Constant`, the
+      # method is not in the supported set, or the Ruby call raises `Math::DomainError` / `RangeError`
+      # (domain-error inputs like `Math.sqrt(-1)`) returns `nil`, deferring to the next dispatcher tier.
       #
-      # An infinite or NaN result (`Math.log(0.0)` → `-Infinity`) is
-      # still folded — `Constant[Float]` carries those values, matching
-      # `ConstantFolding`'s treatment of `Float / 0`.
+      # An infinite or NaN result (`Math.log(0.0)` → `-Infinity`) is still folded — `Constant[Float]`
+      # carries those values, matching `ConstantFolding`'s treatment of `Float / 0`.
       module MathFolding
         MATH_UNARY = Set[
           :sqrt, :cbrt, :exp, :log2, :log10, :log1p, :expm1,
@@ -64,8 +55,7 @@ module Rigor
           args = context.args
           return nil unless SingletonFolding.receiver?(receiver, "Math")
 
-          # `log` is variadic (1 or 2 args), so it cannot live in the
-          # fixed-arity sets above.
+          # `log` is variadic (1 or 2 args), so it cannot live in the fixed-arity sets above.
           return fold_log(args) if method_name == :log
           return fold_unary(method_name, args) if MATH_UNARY.include?(method_name)
           return fold_binary(method_name, args) if MATH_BINARY.include?(method_name)
@@ -74,8 +64,8 @@ module Rigor
           nil
         end
 
-        # Unwraps a numeric `Constant` argument to its Ruby value.
-        # Returns nil for any non-`Constant` or non-`Numeric` carrier.
+        # Unwraps a numeric `Constant` argument to its Ruby value. Returns nil for any non-`Constant` or
+        # non-`Numeric` carrier.
         def numeric_constant(arg)
           return nil unless arg.is_a?(Type::Constant)
 
@@ -106,8 +96,7 @@ module Rigor
           nil
         end
 
-        # `Math.log(x)` and `Math.log(x, base)` — the only variadic
-        # `Math` function.
+        # `Math.log(x)` and `Math.log(x, base)` — the only variadic `Math` function.
         def fold_log(args)
           return nil unless [1, 2].include?(args.size)
 
@@ -119,8 +108,8 @@ module Rigor
           nil
         end
 
-        # `Math.frexp` / `Math.lgamma` return a two-element array;
-        # lift it to `Tuple[Constant[Float], Constant[Integer]]`.
+        # `Math.frexp` / `Math.lgamma` return a two-element array; lift it to
+        # `Tuple[Constant[Float], Constant[Integer]]`.
         def fold_tuple_unary(method_name, args)
           return nil unless args.size == 1
 

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

@@ -5,25 +5,20 @@ 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.
+      # 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).
+      # 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.
+        # 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?
@@ -56,9 +51,8 @@ module Rigor
           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.
+        # `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
 
@@ -69,12 +63,10 @@ module Rigor
           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.
+        # `#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

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

@@ -7,49 +7,32 @@ module Rigor
     module MethodDispatcher
       # `Method` (and friends) precision tier.
       #
-      # Two folds make a `Method` carrier round-trip with its
-      # binding visible:
+      # Two folds make a `Method` carrier round-trip with its binding visible:
       #
-      # 1. **Forward** — `<receiver>.method(:sym)` (or
-      #    `.method("sym")`) lifts to {Type::BoundMethod}
-      #    carrying the receiver type AND the resolved Symbol.
-      #    Calling with a non-literal symbol-shaped argument
-      #    declines so the RBS tier still answers
-      #    `Nominal[Method]`.
-      # 2. **Backward** — `Type::BoundMethod#call(...)` /
-      #    `#()` (Prism lowers `.()` into a CallNode whose
-      #    `name` is `:call`) / `#[](...)` substitutes the
-      #    bound `(receiver_type, method_name)` and recurses
-      #    back into `MethodDispatcher.dispatch`. The
-      #    re-entrant call lets the substituted dispatch
-      #    consume every tier the original call site would
-      #    have — constant folding, shape dispatch, RBS,
-      #    plugin contributions, etc. The original block_type
-      #    / environment / call_node / scope are threaded
-      #    through unchanged so capture-sensitive tiers (the
-      #    block fold) keep working.
+      # 1. **Forward** — `<receiver>.method(:sym)` (or `.method("sym")`) lifts to {Type::BoundMethod}
+      #    carrying the receiver type AND the resolved Symbol. Calling with a non-literal symbol-shaped
+      #    argument declines so the RBS tier still answers `Nominal[Method]`.
+      # 2. **Backward** — `Type::BoundMethod#call(...)` / `#()` (Prism lowers `.()` into a CallNode whose
+      #    `name` is `:call`) / `#[](...)` substitutes the bound `(receiver_type, method_name)` and
+      #    recurses back into `MethodDispatcher.dispatch`. The re-entrant call lets the substituted
+      #    dispatch consume every tier the original call site would have — constant folding, shape
+      #    dispatch, RBS, plugin contributions, etc. The original block_type / environment / call_node /
+      #    scope are threaded through unchanged so capture-sensitive tiers (the block fold) keep working.
       #
-      # Lives ABOVE the standard precision-tier chain so the
-      # RBS tier never sees a `BoundMethod` receiver — `Method`
-      # erasure means RBS would otherwise return
-      # `Method#call: (*untyped) -> untyped`, which is exactly
-      # the precision loss the carrier exists to avoid.
+      # Lives ABOVE the standard precision-tier chain so the RBS tier never sees a `BoundMethod` receiver —
+      # `Method` erasure means RBS would otherwise return `Method#call: (*untyped) -> untyped`, which is
+      # exactly the precision loss the carrier exists to avoid.
       module MethodFolding
         module_function
 
-        # Forward fold. Returns a {Type::BoundMethod} when the
-        # call shape is `<receiver>.method(:name)` /
-        # `.method("name")` with a precisely-known Symbol /
-        # String argument. Declines on every other shape so
-        # the RBS tier still answers `Method` for non-folding
-        # cases.
+        # Forward fold. Returns a {Type::BoundMethod} when the call shape is `<receiver>.method(:name)` /
+        # `.method("name")` with a precisely-known Symbol / String argument. Declines on every other shape
+        # so the RBS tier still answers `Method` for non-folding cases.
         #
         # @param receiver [Rigor::Type] caller's receiver
-        # @param method_name [Symbol] the method being
-        #   dispatched on `receiver` — only `:method` triggers
+        # @param method_name [Symbol] the method being dispatched on `receiver` — only `:method` triggers
         #   the fold.
-        # @param args [Array<Rigor::Type>] caller's argument
-        #   types in order. Only the single-argument case
+        # @param args [Array<Rigor::Type>] caller's argument types in order. Only the single-argument case
         #   matches; other arities decline.
         def try_dispatch(context)
           receiver = context.receiver
@@ -64,35 +47,24 @@ module Rigor
           Type::Combinator.bound_method_of(receiver, bound_name)
         end
 
-        # Backward fold. Recurses into `MethodDispatcher.dispatch`
-        # with the bound `(receiver_type, method_name)`. The
-        # `block_type` / `environment` / `call_node` / `scope`
-        # are forwarded so every downstream tier (constant
-        # folding, shape dispatch, plugin contributions, …)
-        # keeps the original call site's context. Returns
-        # `Dynamic[top]` rather than `nil` when the recursive
-        # dispatch declines so the call site still ends in a
-        # well-defined type (the gradual-safety net mirrors
-        # the engine's "BoundMethod erases to `Method`,
-        # `Method#call: (*untyped) -> untyped`" RBS fallback).
+        # Backward fold. Recurses into `MethodDispatcher.dispatch` with the bound `(receiver_type,
+        # method_name)`. The `block_type` / `environment` / `call_node` / `scope` are forwarded so every
+        # downstream tier (constant folding, shape dispatch, plugin contributions, …) keeps the original
+        # call site's context. Returns `Dynamic[top]` rather than `nil` when the recursive dispatch declines
+        # so the call site still ends in a well-defined type (the gradual-safety net mirrors the engine's
+        # "BoundMethod erases to `Method`, `Method#call: (*untyped) -> untyped`" RBS fallback).
         def try_backward(context)
           receiver = context.receiver
           method_name = context.method_name
           return nil unless receiver.is_a?(Type::BoundMethod)
           return nil unless backward_method?(method_name)
 
-          # `Method#curry` is treated as identity on the carrier
-          # — `<bound>.curry` keeps the same
-          # `(receiver_type, method_name)` so a subsequent
-          # `<curried>.call` still routes through the recursive
-          # dispatch below. This is correct for the dominant
-          # no-arg form (`.curry.call`); partially-applied
-          # forms (`.curry(n).call(a)`) lose precision and fall
-          # through to RBS via the trailing
-          # `Type::Combinator.untyped`. A faithful
-          # `Type::CurriedBoundMethod(receiver_type,
-          # method_name, accumulated_args)` carrier is reserved
-          # for a future slice when concrete user demand
+          # `Method#curry` is treated as identity on the carrier — `<bound>.curry` keeps the same
+          # `(receiver_type, method_name)` so a subsequent `<curried>.call` still routes through the
+          # recursive dispatch below. This is correct for the dominant no-arg form (`.curry.call`);
+          # partially-applied forms (`.curry(n).call(a)`) lose precision and fall through to RBS via the
+          # trailing `Type::Combinator.untyped`. A faithful `Type::CurriedBoundMethod(receiver_type,
+          # method_name, accumulated_args)` carrier is reserved for a future slice when concrete user demand
           # surfaces.
           return receiver if method_name == :curry
 
@@ -106,14 +78,10 @@ module Rigor
             scope: context.scope
           ) || Type::Combinator.untyped
         end
-        # `Method#call` / `Method#()` and `Method#[]` are the
-        # invocation entry points on the `Method` API; the
-        # alias `===` is also `call` semantically but is more
-        # commonly used as a case-equality predicate, so we
-        # do NOT fold through it (the case/when narrowing path
-        # already special-cases `===` for branch typing).
-        # `Method#curry` rides through as identity (see the
-        # comment in `try_backward`).
+        # `Method#call` / `Method#()` and `Method#[]` are the invocation entry points on the `Method` API;
+        # the alias `===` is also `call` semantically but is more commonly used as a case-equality
+        # predicate, so we do NOT fold through it (the case/when narrowing path already special-cases `===`
+        # for branch typing). `Method#curry` rides through as identity (see the comment in `try_backward`).
         BACKWARD_METHOD_NAMES = %i[call [] curry].freeze
         private_constant :BACKWARD_METHOD_NAMES
 
@@ -121,11 +89,9 @@ module Rigor
           BACKWARD_METHOD_NAMES.include?(method_name)
         end
 
-        # `Object#method` accepts both Symbol and String at
-        # runtime (the latter coerced via `to_sym`). The
-        # `Constant<String>` form is rare in production code
-        # but cheap to support and matches Ruby's documented
-        # contract.
+        # `Object#method` accepts both Symbol and String at runtime (the latter coerced via `to_sym`). The
+        # `Constant<String>` form is rare in production code but cheap to support and matches Ruby's
+        # documented contract.
         def symbol_name_of(arg)
           return nil unless arg.is_a?(Type::Constant)