rigortype 0.2.7 → 0.2.8

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

@@ -7,40 +7,31 @@ require_relative "singleton_folding"
 module Rigor
   module Inference
     module MethodDispatcher
-      # Folds `Shellwords` module-function calls on statically known
-      # string constants.
+      # Folds `Shellwords` module-function calls on statically known string constants.
       #
-      # `Shellwords` is a pure, side-effect-free module whose functions
-      # are deterministic over their inputs — the same string always
-      # produces the same escaped / split / joined result. When all
-      # relevant arguments are `Constant[String]` (or `Tuple` of them
-      # for `join`), the analyzer can evaluate the call at inference
-      # time and return the concrete `Constant<T>` result.
+      # `Shellwords` is a pure, side-effect-free module whose functions are deterministic over their
+      # inputs — the same string always produces the same escaped / split / joined result. When all
+      # relevant arguments are `Constant[String]` (or `Tuple` of them for `join`), the analyzer can
+      # evaluate the call at inference time and return the concrete `Constant<T>` result.
       #
       # === Supported methods
       #
-      # * `escape` / `shellescape(str)` — returns `Constant[String]`.
-      #   `Shellwords.escape("")` → `"''"`, so the result is always
-      #   non-empty; callers that care about the `non-empty-string`
-      #   refinement will get it for free once that carrier is wired
-      #   to scalar-constant returns.
+      # * `escape` / `shellescape(str)` — returns `Constant[String]`. `Shellwords.escape("")` → `"''"`, so
+      #   the result is always non-empty; callers that care about the `non-empty-string` refinement will
+      #   get it for free once that carrier is wired to scalar-constant returns.
       #
-      # * `split` / `shellsplit` / `shellwords(line)` — splits the
-      #   shell command line into tokens, returns
-      #   `Tuple[Constant[String], …]`. Raises `ArgumentError` on
-      #   unmatched quotes; the handler declines (returns `nil`) so
-      #   the RBS tier widens gracefully.
+      # * `split` / `shellsplit` / `shellwords(line)` — splits the shell command line into tokens, returns
+      #   `Tuple[Constant[String], …]`. Raises `ArgumentError` on unmatched quotes; the handler declines
+      #   (returns `nil`) so the RBS tier widens gracefully.
       #
-      # * `join` / `shelljoin(array)` — joins an array of tokens into
-      #   a shell-safe string. Requires a `Tuple` whose every element
-      #   is a `Constant[String]`; returns `Constant[String]`.
+      # * `join` / `shelljoin(array)` — joins an array of tokens into a shell-safe string. Requires a
+      #   `Tuple` whose every element is a `Constant[String]`; returns `Constant[String]`.
       #
       # === Non-constant / unsupported cases
       #
       # Any call where:
       # - the receiver is not `Singleton[Shellwords]`,
-      # - the required argument is not a `Constant[String]` (or
-      #   `Tuple[Constant[String]…]` for `join`),
+      # - the required argument is not a `Constant[String]` (or `Tuple[Constant[String]…]` for `join`),
       # - the method is not in the supported set, or
       # - `Shellwords.split` raises on malformed input
       #
@@ -53,9 +44,8 @@ module Rigor
           SHELLWORDS_ESCAPE_METHODS | SHELLWORDS_SPLIT_METHODS | SHELLWORDS_JOIN_METHODS
         ).freeze
 
-        # Maximum number of tokens `split` may produce before we
-        # decline the fold (same rationale as STRING_ARRAY_LIFT_LIMIT
-        # in ConstantFolding — keep the result Tuple manageable).
+        # Maximum number of tokens `split` may produce before we decline the fold (same rationale as
+        # STRING_ARRAY_LIFT_LIMIT in ConstantFolding — keep the result Tuple manageable).
         SHELLWORDS_SPLIT_LIMIT = 64
 
         private_constant :SHELLWORDS_ESCAPE_METHODS, :SHELLWORDS_SPLIT_METHODS,
@@ -91,8 +81,8 @@ module Rigor
           Type::Combinator.constant_of(Shellwords.escape(str))
         end
 
-        # `Shellwords.split(line)` / `.shellsplit` / `.shellwords` —
-        # one String arg, result lifted to Tuple[Constant[String]…].
+        # `Shellwords.split(line)` / `.shellsplit` / `.shellwords` — one String arg, result lifted to
+        # Tuple[Constant[String]…].
         def fold_split(args)
           return nil unless args.size == 1
 
@@ -104,13 +94,13 @@ module Rigor
 
           Type::Combinator.tuple_of(*tokens.map { |t| Type::Combinator.constant_of(t) })
         rescue ArgumentError
-          # Unmatched quotes / invalid shell syntax — decline so the
-          # RBS tier returns the widened Array[String] envelope.
+          # Unmatched quotes / invalid shell syntax — decline so the RBS tier returns the widened
+          # Array[String] envelope.
           nil
         end
 
-        # `Shellwords.join(array)` / `.shelljoin` — one Tuple arg
-        # whose every element is `Constant[String]`.
+        # `Shellwords.join(array)` / `.shelljoin` — one Tuple arg whose every element is
+        # `Constant[String]`.
         def fold_join(args)
           return nil unless args.size == 1
 

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

@@ -5,38 +5,32 @@ require_relative "../../type"
 module Rigor
   module Inference
     module MethodDispatcher
-      # Shared helpers for the per-singleton folding tiers (CGI, URI,
-      # Shellwords, Math, Time, Regexp, Set, File, …).
+      # Shared helpers for the per-singleton folding tiers (CGI, URI, Shellwords, Math, Time, Regexp, Set,
+      # File, …).
       #
-      # Each of those tiers folds a pure module-/class-function call on
-      # `Constant` receivers, and every one of them opens with the same
-      # two questions:
+      # Each of those tiers folds a pure module-/class-function call on `Constant` receivers, and every one
+      # of them opens with the same two questions:
       #
       #   1. "Is the receiver the `Singleton[X]` I handle?" — a one-line
-      #      `is_a?(Type::Singleton) && class_name == "X"` that used to be
-      #      copied verbatim into nine modules.
-      #   2. "Is this argument a foldable `Constant[String]`?" — the
-      #      `is_a?(Type::Constant) && value.is_a?(String)` unwrap the
-      #      string-folding tiers (CGI / URI / Shellwords / Regexp) gate
-      #      on before evaluating the literal.
+      #      `is_a?(Type::Singleton) && class_name == "X"` that used to be copied verbatim into nine
+      #      modules.
+      #   2. "Is this argument a foldable `Constant[String]`?" — the `is_a?(Type::Constant) &&
+      #      value.is_a?(String)` unwrap the string-folding tiers (CGI / URI / Shellwords / Regexp) gate on
+      #      before evaluating the literal.
       #
-      # Centralising both here keeps the receiver-shape and
-      # constant-unwrap knowledge in one place: if `Type::Singleton` or
-      # `Type::Constant` ever changes shape, there is a single edit
-      # rather than nine. The per-tier fold bodies stay where they are —
-      # only the shared gate moves.
+      # Centralising both here keeps the receiver-shape and constant-unwrap knowledge in one place: if
+      # `Type::Singleton` or `Type::Constant` ever changes shape, there is a single edit rather than nine.
+      # The per-tier fold bodies stay where they are — only the shared gate moves.
       module SingletonFolding
         module_function
 
-        # True when `receiver` is the class/module singleton named
-        # `class_name` (e.g. `Singleton[Math]`).
+        # True when `receiver` is the class/module singleton named `class_name` (e.g. `Singleton[Math]`).
         def receiver?(receiver, class_name)
           receiver.is_a?(Type::Singleton) && receiver.class_name == class_name
         end
 
-        # The `String` value carried by a `Constant[String]` argument, or
-        # `nil` for any other carrier. Callers fold when this is non-nil
-        # and decline (return nil, deferring to the RBS tier) otherwise.
+        # The `String` value carried by a `Constant[String]` argument, or `nil` for any other carrier.
+        # Callers fold when this is non-nil and decline (return nil, deferring to the RBS tier) otherwise.
         def constant_string(arg)
           return nil unless arg.is_a?(Type::Constant)
 

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

@@ -7,38 +7,32 @@ require_relative "member_shape_projection"
 module Rigor
   module Inference
     module MethodDispatcher
-      # ADR-48 Struct follow-up — `Struct.new` value folding, the mutable
-      # sibling of {DataFolding}. Same fully-decidable-shape, degrade-on-any-
-      # uncertainty discipline, with one extra premise the immutable `Data`
-      # path does not need: **mutation soundness.**
+      # ADR-48 Struct follow-up — `Struct.new` value folding, the mutable sibling of {DataFolding}. Same
+      # fully-decidable-shape, degrade-on-any-uncertainty discipline, with one extra premise the immutable
+      # `Data` path does not need: **mutation soundness.**
       #
-      # A `Struct` instance is mutable (`s.x = v`, `s[:x] = v`, escape), so a
-      # member map bound to a variable can be invalidated by a later write.
-      # This slice (ADR-48 slices 1+2 in the sound *transient* form) folds a
-      # member read ONLY off a **fresh** instance — the transient receiver of
-      # a `.new(...).x` / `.with(...).x` chain, which provably cannot have
-      # been mutated between materialisation and the read. A member read off
-      # a *stored* binding degrades to `Dynamic[top]` rather than fold a
-      # possibly-stale value. Promoting the fold to mutation-free bound
-      # locals is the deferred slice 3 (relax the fresh-receiver gate to a
-      # fold-safe-local scan); precise mutated-member re-typing is slice 4.
+      # A `Struct` instance is mutable (`s.x = v`, `s[:x] = v`, escape), so a member map bound to a
+      # variable can be invalidated by a later write. This slice (ADR-48 slices 1+2 in the sound
+      # *transient* form) folds a member read ONLY off a **fresh** instance — the transient receiver of a
+      # `.new(...).x` / `.with(...).x` chain, which provably cannot have been mutated between
+      # materialisation and the read. A member read off a *stored* binding degrades to `Dynamic[top]`
+      # rather than fold a possibly-stale value. Promoting the fold to mutation-free bound locals is the
+      # deferred slice 3 (relax the fresh-receiver gate to a fold-safe-local scan); precise mutated-member
+      # re-typing is slice 4.
       #
       # Responsibilities:
       #
-      # 1. `Struct.new(:x, :y [, keyword_init: <bool>])` on a
-      #    `Singleton[Struct]` receiver, literal-Symbol members, NO block ->
-      #    `StructClass{members:, keyword_init:}`. A block / non-literal
-      #    members defer.
-      # 2. `.new` / `.[]` on a `StructClass` (or a `Singleton[Point]` with a
-      #    recorded struct layout) -> a `StructInstance`, the member map built
-      #    from the call's arguments (positional or keyword per the class's
-      #    `keyword_init`). A form / arity mismatch degrades to `Dynamic[top]`
-      #    rather than a wrong member map. `.members` on the class folds.
-      # 3. member reads + `[]` / `to_h` / `deconstruct` / `deconstruct_keys`
-      #    / `members` / `with` on a *fresh* `StructInstance` -> the precise
-      #    projected type; member *setters* (`s.x = v`) return the assigned
-      #    value type. Unhandled / stored-receiver calls return nil so the
-      #    pipeline projects the instance to its nominal through RbsDispatch.
+      # 1. `Struct.new(:x, :y [, keyword_init: <bool>])` on a `Singleton[Struct]` receiver, literal-Symbol
+      #    members, NO block -> `StructClass{members:, keyword_init:}`. A block / non-literal members
+      #    defer.
+      # 2. `.new` / `.[]` on a `StructClass` (or a `Singleton[Point]` with a recorded struct layout) -> a
+      #    `StructInstance`, the member map built from the call's arguments (positional or keyword per the
+      #    class's `keyword_init`). A form / arity mismatch degrades to `Dynamic[top]` rather than a wrong
+      #    member map. `.members` on the class folds.
+      # 3. member reads + `[]` / `to_h` / `deconstruct` / `deconstruct_keys` / `members` / `with` on a
+      #    *fresh* `StructInstance` -> the precise projected type; member *setters* (`s.x = v`) return the
+      #    assigned value type. Unhandled / stored-receiver calls return nil so the pipeline projects the
+      #    instance to its nominal through RbsDispatch.
       #
       # See docs/adr/48-data-struct-value-folding.md § "Struct follow-up".
       module StructFolding
@@ -64,12 +58,10 @@ module Rigor
           end
         end
 
-        # A `Struct.new`-defined class assigned to a constant (or a
-        # `class Point < Struct.new(...)` subclass) is canonicalised by the
-        # engine to `Singleton[Point]`, not a `StructClass` — so its member
-        # layout is read from the project side-table the scope indexer built
-        # (`Scope#struct_member_layout`) rather than from the receiver
-        # carrier.
+        # A `Struct.new`-defined class assigned to a constant (or a `class Point < Struct.new(...)`
+        # subclass) is canonicalised by the engine to `Singleton[Point]`, not a `StructClass` — so its
+        # member layout is read from the project side-table the scope indexer built
+        # (`Scope#struct_member_layout`) rather than from the receiver carrier.
         def fold_named_new(singleton, context)
           scope = context.scope
           return nil if scope.nil?
@@ -84,8 +76,8 @@ module Rigor
 
         def fold_struct_new(context)
           return nil unless context.method_name == :new
-          # Block-form (`Struct.new(:x) do ... end`) defers — the named
-          # constant/subclass forms still fold via the layout side-table.
+          # Block-form (`Struct.new(:x) do ... end`) defers — the named constant/subclass forms still fold
+          # via the layout side-table.
           return nil unless context.block_type.nil?
 
           parsed = parse_struct_new_args(context.args)
@@ -94,10 +86,9 @@ module Rigor
           Type::Combinator.struct_class_of(members: parsed[:members], keyword_init: parsed[:keyword_init])
         end
 
-        # Parses `Struct.new`'s arguments into `{ members:, keyword_init: }`,
-        # or nil when any argument is non-conforming (a dynamic member name,
-        # an unexpected trailing keyword). Handles the optional leading String
-        # class name and the trailing `keyword_init:` option hash.
+        # Parses `Struct.new`'s arguments into `{ members:, keyword_init: }`, or nil when any argument is
+        # non-conforming (a dynamic member name, an unexpected trailing keyword). Handles the optional
+        # leading String class name and the trailing `keyword_init:` option hash.
         def parse_struct_new_args(args)
           rest = args.dup
           keyword_init = false
@@ -125,9 +116,9 @@ module Rigor
           { members: members, keyword_init: keyword_init }
         end
 
-        # A trailing hash is the `Struct.new` options hash only when it is a
-        # closed shape whose sole key is `:keyword_init`. Any other key means
-        # the call is not a recognisable member-list definition -> defer.
+        # A trailing hash is the `Struct.new` options hash only when it is a closed shape whose sole key is
+        # `:keyword_init`. Any other key means the call is not a recognisable member-list definition ->
+        # defer.
         def struct_options_hash?(shape)
           shape.closed? && shape.optional_keys.empty? &&
             shape.pairs.keys.all? { |key| key == :keyword_init }
@@ -154,10 +145,9 @@ module Rigor
           Type::Combinator.struct_instance_of(members: map, class_name: class_name)
         end
 
-        # Builds the member -> type map honouring the class's `keyword_init`
-        # flag: a `keyword_init: true` struct accepts only the keyword form,
-        # a positional struct only the positional form. The mismatched form
-        # is a different runtime shape, so it degrades rather than fold.
+        # Builds the member -> type map honouring the class's `keyword_init` flag: a `keyword_init: true`
+        # struct accepts only the keyword form, a positional struct only the positional form. The
+        # mismatched form is a different runtime shape, so it degrades rather than fold.
         def member_map_for_new(members, keyword_init, context)
           if keyword_new?(context)
             keyword_init ? keyword_member_map(members, context.args) : nil
@@ -166,9 +156,9 @@ module Rigor
           end
         end
 
-        # `Point.new(x: 1)` arrives as a single trailing `HashShape` whose
-        # call node is a `KeywordHashNode`; distinguishing it from a
-        # positional hash needs the call node (both type to a `HashShape`).
+        # `Point.new(x: 1)` arrives as a single trailing `HashShape` whose call node is a
+        # `KeywordHashNode`; distinguishing it from a positional hash needs the call node (both type to a
+        # `HashShape`).
         def keyword_new?(context)
           node = context.call_node
           return false if node.nil?
@@ -179,9 +169,9 @@ module Rigor
           arguments.last.is_a?(Prism::KeywordHashNode)
         end
 
-        # `Struct.new(:a, :b).new(v)` is legal — trailing members default to
-        # `nil` — so fewer positionals than members pad with `Constant[nil]`;
-        # more positionals than members is an ArgumentError -> degrade.
+        # `Struct.new(:a, :b).new(v)` is legal — trailing members default to `nil` — so fewer positionals
+        # than members pad with `Constant[nil]`; more positionals than members is an ArgumentError ->
+        # degrade.
         def positional_member_map(members, args)
           return nil if args.size > members.size
 
@@ -190,9 +180,8 @@ module Rigor
           end
         end
 
-        # `Struct.new(:a, :b).new(a: 1)` is legal — omitted members default
-        # to `nil` — so a keyword subset pads the rest; an unknown key is an
-        # ArgumentError -> degrade.
+        # `Struct.new(:a, :b).new(a: 1)` is legal — omitted members default to `nil` — so a keyword subset
+        # pads the rest; an unknown key is an ArgumentError -> degrade.
         def keyword_member_map(members, args)
           return nil unless args.size == 1
 
@@ -204,9 +193,8 @@ module Rigor
           members.to_h { |name| [name, shape.pairs[name] || Type::Combinator.constant_of(nil)] }
         end
 
-        # A `.new` whose arguments cannot soundly populate the member map
-        # degrades to `Dynamic[top]` (today's behaviour for `Struct.new(...)`
-        # instances), never a wrong map.
+        # A `.new` whose arguments cannot soundly populate the member map degrades to `Dynamic[top]`
+        # (today's behaviour for `Struct.new(...)` instances), never a wrong map.
         def degraded_instance
           Type::Combinator.untyped
         end
@@ -218,27 +206,24 @@ module Rigor
           args = context.args
           members = instance.members
 
-          # Member setter `s.x = v`: returns the assigned value type. Sound
-          # regardless of mutation state (it models the setter's own return),
-          # and avoids a fall-through undefined-method on a writer the
-          # existence table does not register.
+          # Member setter `s.x = v`: returns the assigned value type. Sound regardless of mutation state
+          # (it models the setter's own return), and avoids a fall-through undefined-method on a writer
+          # the existence table does not register.
           setter = member_setter_target(method_name, members)
           return args.first if setter && args.size == 1
 
           foldable = foldable_receiver?(context)
 
           if members.key?(method_name) && args.empty? && !reader_overridden?(instance, method_name, context.scope)
-            # A stored receiver folds only when the bound local is proven
-            # fold-safe (ADR-48 slice 3 — never mutated / aliased / escaped);
-            # otherwise the member value may be stale, so it degrades to
+            # A stored receiver folds only when the bound local is proven fold-safe (ADR-48 slice 3 — never
+            # mutated / aliased / escaped); otherwise the member value may be stale, so it degrades to
             # `Dynamic[top]` (not nil -> no undefined-method fall-through).
             return foldable ? members.fetch(method_name) : Type::Combinator.untyped
           end
 
-          # Projections fold only off a foldable (fresh, or proven fold-safe)
-          # instance; off any other stored binding they defer to Struct's RBS
-          # (`to_h` / `[]` / `members` / `deconstruct*` all exist on `Struct`),
-          # which is sound and non-regressive.
+          # Projections fold only off a foldable (fresh, or proven fold-safe) instance; off any other
+          # stored binding they defer to Struct's RBS (`to_h` / `[]` / `members` / `deconstruct*` all exist
+          # on `Struct`), which is sound and non-regressive.
           return nil unless foldable
 
           fold_fresh_projection(instance, method_name, args)
@@ -258,9 +243,9 @@ module Rigor
           end
         end
 
-        # The member name a `:<member>=` setter targets, or nil. Comparison
-        # operators (`==`, `>=`, ...) end with `=` too but never strip to a
-        # member symbol, so they fall through to the normal dispatch path.
+        # The member name a `:<member>=` setter targets, or nil. Comparison operators (`==`, `>=`, ...) end
+        # with `=` too but never strip to a member symbol, so they fall through to the normal dispatch
+        # path.
         def member_setter_target(method_name, members)
           name = method_name.to_s
           return nil unless name.end_with?("=")
@@ -269,17 +254,16 @@ module Rigor
           members.key?(base) ? base : nil
         end
 
-        # A member read is foldable when the receiver is either FRESH (the
-        # transient result of a `.new(...)`/`.with(...)` chain, which cannot
-        # have been mutated between materialisation and this read) or a
-        # FOLD-SAFE stored local (ADR-48 slice 3 — `StructFoldSafety` proved
-        # the binding is never mutated / aliased / escaped in its scope).
+        # A member read is foldable when the receiver is either FRESH (the transient result of a
+        # `.new(...)`/`.with(...)` chain, which cannot have been mutated between materialisation and this
+        # read) or a FOLD-SAFE stored local (ADR-48 slice 3 — `StructFoldSafety` proved the binding is
+        # never mutated / aliased / escaped in its scope).
         def foldable_receiver?(context)
           fresh_receiver?(context) || fold_safe_local_receiver?(context)
         end
 
-        # A fresh receiver is the transient result of a chained call
-        # (`Point.new(1, 2).x`, `inst.with(x: 9).y`).
+        # A fresh receiver is the transient result of a chained call (`Point.new(1, 2).x`,
+        # `inst.with(x: 9).y`).
         def fresh_receiver?(context)
           node = context.call_node
           return false if node.nil?
@@ -287,8 +271,8 @@ module Rigor
           node.receiver.is_a?(Prism::CallNode)
         end
 
-        # A fold-safe stored receiver is a local-variable read whose name the
-        # body's fold-safe set (on the scope) marks as never mutated.
+        # A fold-safe stored receiver is a local-variable read whose name the body's fold-safe set (on the
+        # scope) marks as never mutated.
         def fold_safe_local_receiver?(context)
           node = context.call_node
           receiver = node&.receiver

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

@@ -6,28 +6,23 @@ require_relative "singleton_folding"
 module Rigor
   module Inference
     module MethodDispatcher
-      # Folds the zone-pinned `Time` class constructors on statically
-      # known arguments.
+      # Folds the zone-pinned `Time` class constructors on statically known arguments.
       #
-      # Only `Time.utc` / `Time.gm` are folded. They pin the result
-      # to UTC, so the literal is machine-independent — every reader
-      # (`year`, `hour`, `utc_offset`, `strftime`, …) yields the same
+      # Only `Time.utc` / `Time.gm` are folded. They pin the result to UTC, so the literal is
+      # machine-independent — every reader (`year`, `hour`, `utc_offset`, `strftime`, …) yields the same
       # answer on any analysis host.
       #
-      # `Time.now` (non-deterministic), `Time.at` / `Time.local` /
-      # `Time.mktime` / `Time.new` (local-zone — the result's wall
-      # clock and `utc_offset` depend on the analysis machine's
-      # timezone) are deliberately NOT folded; they keep their
-      # `Nominal[Time]` RBS answer. For the same reason `Time#getlocal`
-      # is blocklisted in `TIME_CATALOG` so a folded `Constant[Time]`
-      # cannot produce a machine-dependent local-zone copy.
+      # `Time.now` (non-deterministic), `Time.at` / `Time.local` / `Time.mktime` / `Time.new` (local-zone —
+      # the result's wall clock and `utc_offset` depend on the analysis machine's timezone) are
+      # deliberately NOT folded; they keep their `Nominal[Time]` RBS answer. For the same reason
+      # `Time#getlocal` is blocklisted in `TIME_CATALOG` so a folded `Constant[Time]` cannot produce a
+      # machine-dependent local-zone copy.
       module TimeFolding
         TIME_UTC_METHODS = Set[:utc, :gm].freeze
         private_constant :TIME_UTC_METHODS
 
-        # `Time.utc` accepts the 1–7 positional (year-first) form and
-        # a 10-arg (sec-first) form; cap the arity so a malformed
-        # call declines cheaply rather than reaching the constructor.
+        # `Time.utc` accepts the 1–7 positional (year-first) form and a 10-arg (sec-first) form; cap the
+        # arity so a malformed call declines cheaply rather than reaching the constructor.
         MAX_TIME_ARITY = 10
         private_constant :MAX_TIME_ARITY
 

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

@@ -7,23 +7,19 @@ require_relative "singleton_folding"
 module Rigor
   module Inference
     module MethodDispatcher
-      # Folds `URI` module-function calls on statically known
-      # string constants.
+      # Folds `URI` module-function calls on statically known string constants.
       #
-      # `URI.encode_www_form_component` / `decode_www_form_component`
-      # and the newer `encode_uri_component` / `decode_uri_component`
-      # are pure, deterministic functions over their string inputs.
-      # When the argument is a `Constant[String]`, the analyzer can
-      # evaluate the call at inference time and return the concrete
-      # `Constant[String]` result.
+      # `URI.encode_www_form_component` / `decode_www_form_component` and the newer `encode_uri_component`
+      # / `decode_uri_component` are pure, deterministic functions over their string inputs. When the
+      # argument is a `Constant[String]`, the analyzer can evaluate the call at inference time and return
+      # the concrete `Constant[String]` result.
       #
       # === Supported methods
       #
-      # * `encode_www_form_component(str)` / `decode_www_form_component(str)` —
-      #   RFC 3986 percent-encode / decode. Returns `Constant[String]`.
-      # * `encode_uri_component(str)` / `decode_uri_component(str)` —
-      #   Same encoding but may preserve additional reserved chars
-      #   (Ruby 3.2+). Returns `Constant[String]`.
+      # * `encode_www_form_component(str)` / `decode_www_form_component(str)` — RFC 3986 percent-encode /
+      #   decode. Returns `Constant[String]`.
+      # * `encode_uri_component(str)` / `decode_uri_component(str)` — Same encoding but may preserve
+      #   additional reserved chars (Ruby 3.2+). Returns `Constant[String]`.
       #
       # === Non-constant / unsupported cases
       #