rigortype 0.2.7 → 0.2.8

data/lib/rigor/inference/builtins/proc_catalog.rb

@@ -5,92 +5,69 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Proc` / `Method` / `UnboundMethod` catalog. Singleton —
-      # load once, consult during dispatch.
+      # `Proc` / `Method` / `UnboundMethod` catalog. Singleton — load once, consult during dispatch.
       #
-      # The three callable carriers are imported together because
-      # `Init_Proc` registers them in a single C init block. They
-      # share the same fundamental hazard at the catalog tier:
-      # most of their public methods invoke the wrapped Ruby code
-      # (the proc body, the bound method's receiver, …) and that
-      # code can do anything — read mutable state, call I/O, return
-      # different values on successive calls. The static C-body
-      # classifier marks these `:leaf` because the C functions
-      # themselves do not call `rb_funcall*` / `rb_yield` directly
-      # (they delegate through the VM's optimised call paths and
-      # method-entry table), but folding any of them at compile
-      # time would freeze a value the runtime never actually
-      # produces twice.
+      # The three callable carriers are imported together because `Init_Proc` registers them in a single
+      # C init block. They share the same fundamental hazard at the catalog tier: most of their public
+      # methods invoke the wrapped Ruby code (the proc body, the bound method's receiver, …) and that code
+      # can do anything — read mutable state, call I/O, return different values on successive calls. The
+      # static C-body classifier marks these `:leaf` because the C functions themselves do not call
+      # `rb_funcall*` / `rb_yield` directly (they delegate through the VM's optimised call paths and
+      # method-entry table), but folding any of them at compile time would freeze a value the runtime
+      # never actually produces twice.
       #
-      # The blocklist below errs aggressively on the side of
-      # caution: a hypothetical future `Constant<Proc>` /
-      # `Constant<Method>` / `Constant<UnboundMethod>` carrier
-      # would have very little to gain from these folds and a
-      # great deal to lose if user code ran behind the analyzer's
-      # back. Reflective readers (`#arity`, `#parameters`,
-      # `#source_location`, `#name`, `#owner`, `#receiver`) remain
-      # foldable; the RBS tier still resolves return types for
-      # the blocklisted methods so callers do not lose precision.
+      # The blocklist below errs aggressively on the side of caution: a hypothetical future
+      # `Constant<Proc>` / `Constant<Method>` / `Constant<UnboundMethod>` carrier would have very little
+      # to gain from these folds and a great deal to lose if user code ran behind the analyzer's back.
+      # Reflective readers (`#arity`, `#parameters`, `#source_location`, `#name`, `#owner`, `#receiver`)
+      # remain foldable; the RBS tier still resolves return types for the blocklisted methods so callers
+      # do not lose precision.
       PROC_CATALOG = MethodCatalog.for_topic(
         "proc",
         mutating_selectors: {
           "Proc" => Set[
-            # `#call` / `#[]` / `#===` / `#yield` invoke the proc
-            # body. The C body routes through
-            # `OPTIMIZED_METHOD_TYPE_CALL` (a VM fast path the
-            # classifier cannot see into); the proc body can do
-            # anything — read globals, mutate captured locals,
-            # raise. MUST decline to fold.
+            # `#call` / `#[]` / `#===` / `#yield` invoke the proc body. The C body routes through
+            # `OPTIMIZED_METHOD_TYPE_CALL` (a VM fast path the classifier cannot see into); the proc body
+            # can do anything — read globals, mutate captured locals, raise. MUST decline to fold.
             :call,
             :[],
             :===,
             :yield,
-            # `#curry` / `#<<` / `#>>` allocate a fresh `Proc`
-            # that closes over the receiver (and, for `<<` /
-            # `>>`, over the argument). Folding would freeze a
-            # specific `Proc` instance whose identity the runtime
-            # never actually produces (object_id differs every
-            # call), so the catalog tier declines.
+            # `#curry` / `#<<` / `#>>` allocate a fresh `Proc` that closes over the receiver (and, for
+            # `<<` / `>>`, over the argument). Folding would freeze a specific `Proc` instance whose
+            # identity the runtime never actually produces (object_id differs every call), so the catalog
+            # tier declines.
             :curry,
             :<<,
             :>>,
-            # `#to_proc` returns `self` for `Proc` (cheap), but
-            # blocking it keeps the rule shape uniform across the
-            # three callable carriers (Method#to_proc allocates a
-            # fresh `Proc`).
+            # `#to_proc` returns `self` for `Proc` (cheap), but blocking it keeps the rule shape uniform
+            # across the three callable carriers (Method#to_proc allocates a fresh `Proc`).
             :to_proc,
-            # Identity-based equality and hashing: `#hash` is
-            # derived from the underlying ISeq pointer; `#==` /
-            # `#eql?` compare ISeq + binding. Folding to a
-            # `Constant<Integer>` / `Constant<bool>` would freeze
-            # an answer that depends on memory layout. Defensive.
+            # Identity-based equality and hashing: `#hash` is derived from the underlying ISeq pointer;
+            # `#==` / `#eql?` compare ISeq + binding. Folding to a `Constant<Integer>` / `Constant<bool>`
+            # would freeze an answer that depends on memory layout. Defensive.
             :hash,
             :==,
             :eql?,
-            # `initialize_copy` is blocklisted by convention so a
-            # hypothetical future `Constant<Proc>` carrier cannot
-            # fold an aliasing copy through the catalog.
+            # `initialize_copy` is blocklisted by convention so a hypothetical future `Constant<Proc>`
+            # carrier cannot fold an aliasing copy through the catalog.
             :initialize_copy
           ],
           "Method" => Set[
-            # `#call` / `#[]` / `#===` invoke the bound method.
-            # Same hazard as `Proc#call`: arbitrary user code,
-            # arbitrary side effects.
+            # `#call` / `#[]` / `#===` invoke the bound method. Same hazard as `Proc#call`: arbitrary user
+            # code, arbitrary side effects.
             :call,
             :[],
             :===,
-            # `#curry` / `#<<` / `#>>` allocate a fresh `Proc`
-            # that closes over the bound method.
+            # `#curry` / `#<<` / `#>>` allocate a fresh `Proc` that closes over the bound method.
             :curry,
             :<<,
             :>>,
-            # `#to_proc` allocates a fresh `Proc` wrapping the
-            # bound method — folding would freeze its object_id.
-            # The classifier already marks it `:block_dependent`,
-            # but the explicit entry keeps the intent obvious.
+            # `#to_proc` allocates a fresh `Proc` wrapping the bound method — folding would freeze its
+            # object_id. The classifier already marks it `:block_dependent`, but the explicit entry keeps
+            # the intent obvious.
             :to_proc,
-            # `#unbind` allocates a fresh `UnboundMethod` whose
-            # identity differs every call.
+            # `#unbind` allocates a fresh `UnboundMethod` whose identity differs every call.
             :unbind,
             # Identity-based equality and hashing.
             :hash,
@@ -100,9 +77,8 @@ module Rigor
             :initialize_copy
           ],
           "UnboundMethod" => Set[
-            # `#bind` allocates a fresh `Method` whose object_id
-            # differs every call; `#bind_call` invokes the bound
-            # method (already classified `:block_dependent`).
+            # `#bind` allocates a fresh `Method` whose object_id differs every call; `#bind_call` invokes
+            # the bound method (already classified `:block_dependent`).
             :bind,
             :bind_call,
             # Identity-based equality and hashing.

data/lib/rigor/inference/builtins/random_catalog.rb

@@ -5,47 +5,36 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Random` catalog. Singleton — load once, consult during
-      # dispatch.
+      # `Random` catalog. Singleton — load once, consult during dispatch.
       #
-      # The static classifier marks most Random methods `:leaf`
-      # because their C bodies do not call `rb_funcall*` /
-      # `rb_yield` / `rb_check_frozen` directly. Random is the
-      # canonical case where that heuristic under-counts: every
-      # call to `#rand` / `#bytes` / `Random.rand` / `Random.bytes`
-      # advances the receiver's Mersenne-Twister state through a
-      # helper (`rand_random` -> `random_real` / `random_ulong_limited`),
-      # so folding any of them statically is unsound.
-      # `Random.new_seed` and `Random.urandom` are non-deterministic
-      # (different output every call); even though they are
-      # functionally pure they would produce a misleading constant
-      # at fold time. The whole class is conservative-by-default
-      # at the catalog tier; precision flows through the RBS layer.
+      # The static classifier marks most Random methods `:leaf` because their C bodies do not call
+      # `rb_funcall*` / `rb_yield` / `rb_check_frozen` directly. Random is the canonical case where that
+      # heuristic under-counts: every call to `#rand` / `#bytes` / `Random.rand` / `Random.bytes` advances
+      # the receiver's Mersenne-Twister state through a helper (`rand_random` -> `random_real` /
+      # `random_ulong_limited`), so folding any of them statically is unsound. `Random.new_seed` and
+      # `Random.urandom` are non-deterministic (different output every call); even though they are
+      # functionally pure they would produce a misleading constant at fold time. The whole class is
+      # conservative-by-default at the catalog tier; precision flows through the RBS layer.
       RANDOM_CATALOG = MethodCatalog.for_topic(
         "random",
         mutating_selectors: {
           "Random" => Set[
-            # `rand_random` -> `random_real` / `random_ulong_limited`
-            # advance the MT state on the receiver (instance #rand)
-            # and on `Random::DEFAULT` (singleton .rand). The
-            # classifier misses the indirect mutator.
+            # `rand_random` -> `random_real` / `random_ulong_limited` advance the MT state on the receiver
+            # (instance #rand) and on `Random::DEFAULT` (singleton .rand). The classifier misses the
+            # indirect mutator.
             :rand,
-            # `random_bytes` / `random_s_bytes` consume MT output
-            # the same way #rand does — every call mutates the
-            # underlying generator.
+            # `random_bytes` / `random_s_bytes` consume MT output the same way #rand does — every call
+            # mutates the underlying generator.
             :bytes,
-            # Non-deterministic: each call produces a fresh seed
-            # via `with_random_seed` reading platform entropy. Folding
-            # to a constant would freeze a value that the runtime
-            # never actually returns twice.
+            # Non-deterministic: each call produces a fresh seed via `with_random_seed` reading platform
+            # entropy. Folding to a constant would freeze a value that the runtime never actually returns
+            # twice.
             :new_seed,
-            # Non-deterministic: reads from platform CSPRNG (e.g.
-            # /dev/urandom). Folding is unsound for the same reason
-            # as `new_seed`.
+            # Non-deterministic: reads from platform CSPRNG (e.g. /dev/urandom). Folding is unsound for
+            # the same reason as `new_seed`.
             :urandom,
-            # `initialize_copy` is blocklisted by convention so a
-            # hypothetical future `Constant<Random>` carrier
-            # cannot fold an aliasing copy through the catalog.
+            # `initialize_copy` is blocklisted by convention so a hypothetical future `Constant<Random>`
+            # carrier cannot fold an aliasing copy through the catalog.
             :initialize_copy
           ]
         }

data/lib/rigor/inference/builtins/range_catalog.rb

@@ -5,35 +5,26 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Range` catalog. Singleton — load once, consult during
-      # dispatch.
+      # `Range` catalog. Singleton — load once, consult during dispatch.
       #
-      # Range is largely immutable: `begin`, `end`, and `excl` are
-      # set at construction by `range_initialize` and never mutated
-      # afterwards. The blocklist below therefore stays small. The
-      # entries we DO need are the iteration methods whose C body
-      # routes through a helper the block/yield regex does not
-      # recognise, so the classifier mis-flags them as `:leaf`
-      # despite yielding to a block.
+      # Range is largely immutable: `begin`, `end`, and `excl` are set at construction by
+      # `range_initialize` and never mutated afterwards. The blocklist below therefore stays small. The
+      # entries we DO need are the iteration methods whose C body routes through a helper the block/yield
+      # regex does not recognise, so the classifier mis-flags them as `:leaf` despite yielding to a block.
       RANGE_CATALOG = MethodCatalog.for_topic(
         "range",
         mutating_selectors: {
           "Range" => Set[
-            # `range_initialize` / `range_initialize_copy` write
-            # `begin`/`end`/`excl` slots on the receiver; classed
-            # `:leaf` because the writes go through the struct
-            # accessor not `rb_check_frozen`. Blocked for symmetry
-            # with String / Array.
+            # `range_initialize` / `range_initialize_copy` write `begin`/`end`/`excl` slots on the
+            # receiver; classed `:leaf` because the writes go through the struct accessor not
+            # `rb_check_frozen`. Blocked for symmetry with String / Array.
             :initialize, :initialize_copy,
-            # `range_reverse_each` yields to its block via
-            # `range_each_func` -> caller's block; the regex
+            # `range_reverse_each` yields to its block via `range_each_func` -> caller's block; the regex
             # classifier follows direct `rb_yield*` calls only.
             :reverse_each,
-            # `range_percent_step` returns an Enumerator unless a
-            # block is supplied, in which case it yields. Treated
-            # as block-dependent so the fold tier never invokes it
-            # against a literal Range and tries to materialise an
-            # Enumerator into a Constant.
+            # `range_percent_step` returns an Enumerator unless a block is supplied, in which case it
+            # yields. Treated as block-dependent so the fold tier never invokes it against a literal Range
+            # and tries to materialise an Enumerator into a Constant.
             :%
           ]
         }

data/lib/rigor/inference/builtins/rational_catalog.rb

@@ -5,23 +5,17 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Rational` catalog. Singleton — load once, consult during
-      # dispatch.
+      # `Rational` catalog. Singleton — load once, consult during dispatch.
       #
-      # Rational is fully immutable: numerator / denominator slots
-      # are written once during `nurat_s_new_internal` and the C
-      # body never reaches for `rb_check_frozen`. Every catalog
-      # entry classifies cleanly (`:leaf`, `:leaf_when_numeric`,
-      # or `:dispatch` for the two methods that delegate into
-      # user-redefinable `==` / `Float()` — `nurat_eqeq_p` and
-      # `nurat_fdiv`). Bang-suffixed mutators do not exist on
-      # Rational.
+      # Rational is fully immutable: numerator / denominator slots are written once during
+      # `nurat_s_new_internal` and the C body never reaches for `rb_check_frozen`. Every catalog entry
+      # classifies cleanly (`:leaf`, `:leaf_when_numeric`, or `:dispatch` for the two methods that
+      # delegate into user-redefinable `==` / `Float()` — `nurat_eqeq_p` and `nurat_fdiv`). Bang-suffixed
+      # mutators do not exist on Rational.
       #
-      # The blocklist therefore stays minimal. `initialize_copy`
-      # is added defensively (mirrors Range / Set) so a
-      # hypothetical future `Constant<Rational>` carrier cannot
-      # fold an aliasing copy through the catalog and surface a
-      # shared mutable handle.
+      # The blocklist therefore stays minimal. `initialize_copy` is added defensively (mirrors Range /
+      # Set) so a hypothetical future `Constant<Rational>` carrier cannot fold an aliasing copy through
+      # the catalog and surface a shared mutable handle.
       RATIONAL_CATALOG = MethodCatalog.for_topic(
         "rational",
         mutating_selectors: {

data/lib/rigor/inference/builtins/re_catalog.rb

@@ -5,70 +5,51 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Regexp` / `MatchData` catalog. Singleton — load once,
-      # consult during dispatch.
+      # `Regexp` / `MatchData` catalog. Singleton — load once, consult during dispatch.
       #
-      # `Init_Regexp` in `references/ruby/re.c` registers BOTH
-      # classes in a single C init block, so the catalog carries
-      # both — `Regexp` (the pattern carrier) plus `MatchData`
-      # (the result-of-match carrier produced by `Regexp#match` /
-      # `String#match` and consulted via `$~`). The catalog wiring
+      # `Init_Regexp` in `references/ruby/re.c` registers BOTH classes in a single C init block, so the
+      # catalog carries both — `Regexp` (the pattern carrier) plus `MatchData` (the result-of-match
+      # carrier produced by `Regexp#match` / `String#match` and consulted via `$~`). The catalog wiring
       # therefore mostly governs:
       #
-      # 1. The reader surface on each class (`Regexp#source`,
-      #    `Regexp#options`, `Regexp#casefold?`, `MatchData#size`,
-      #    `MatchData#captures`, etc.) — RBS-declared returns are
-      #    preserved through dispatch.
-      # 2. The blocklist below, which keeps methods that touch
-      #    process-global state (the `$~` backref) from being
-      #    folded. Regexp matching is observably stateful:
-      #    `Regexp#=~`, `#===` and `#~` all call `rb_backref_set`
-      #    (writing `$~` and the `$1..$N` / `$&` / `` $` `` / `$'`
-      #    aliases). A constant-fold that dropped those calls
-      #    would silently change the visible state of the program,
+      # 1. The reader surface on each class (`Regexp#source`, `Regexp#options`, `Regexp#casefold?`,
+      #    `MatchData#size`, `MatchData#captures`, etc.) — RBS-declared returns are preserved through
+      #    dispatch.
+      # 2. The blocklist below, which keeps methods that touch process-global state (the `$~` backref)
+      #    from being folded. Regexp matching is observably stateful: `Regexp#=~`, `#===` and `#~` all
+      #    call `rb_backref_set` (writing `$~` and the `$1..$N` / `$&` / `` $` `` / `$'` aliases). A
+      #    constant-fold that dropped those calls would silently change the visible state of the program,
       #    so they MUST decline through to the RBS tier.
       #
-      # `Regexp.last_match` and `Regexp.timeout` / `Regexp.timeout=`
-      # are class-level (singleton) methods that also touch
-      # process-global state, but the dispatcher's catalog lookup
-      # only consults `:instance` entries today — class-method calls
-      # on a `Singleton` receiver type take the `meta_*` path in
-      # `MethodDispatcher` rather than walking `CATALOG_BY_CLASS` —
-      # so listing them here would be dead code. Their RBS-tier
-      # signatures already widen the answer enough to keep the
-      # behaviour sound; revisit if the dispatcher ever grows a
-      # singleton-aware catalog path.
+      # `Regexp.last_match` and `Regexp.timeout` / `Regexp.timeout=` are class-level (singleton) methods
+      # that also touch process-global state, but the dispatcher's catalog lookup only consults
+      # `:instance` entries today — class-method calls on a `Singleton` receiver type take the `meta_*`
+      # path in `MethodDispatcher` rather than walking `CATALOG_BY_CLASS` — so listing them here would be
+      # dead code. Their RBS-tier signatures already widen the answer enough to keep the behaviour sound;
+      # revisit if the dispatcher ever grows a singleton-aware catalog path.
       REGEXP_CATALOG = MethodCatalog.for_topic(
         "re",
         mutating_selectors: {
           "Regexp" => Set[
-            # Defensive: aliasing-copy semantics already covered
-            # by the `:mutates_self` classifier, listed here for
-            # symmetry with String / Array / Hash / Range / Set.
+            # Defensive: aliasing-copy semantics already covered by the `:mutates_self` classifier,
+            # listed here for symmetry with String / Array / Hash / Range / Set.
             :initialize_copy,
-            # `=~`, `===`, `~` all run `rb_reg_search` (or call
-            # `rb_backref_set(Qnil)` directly) — every successful
-            # OR failing match writes `$~` and the
-            # `$1..$N` / `$&` / `` $` `` / `$'` aliases. Folding
-            # would discard the visible side effect.
+            # `=~`, `===`, `~` all run `rb_reg_search` (or call `rb_backref_set(Qnil)` directly) — every
+            # successful OR failing match writes `$~` and the `$1..$N` / `$&` / `` $` `` / `$'` aliases.
+            # Folding would discard the visible side effect.
             :=~,
             :"===",
             :~,
-            # `match` is already `:block_dependent` (the C body
-            # yields), but it ALSO writes `$~` regardless of the
-            # block. Listed here so a future extractor that
-            # reclassifies it as `:leaf` (because the yield is
-            # behind a helper) does not silently fold it.
+            # `match` is already `:block_dependent` (the C body yields), but it ALSO writes `$~`
+            # regardless of the block. Listed here so a future extractor that reclassifies it as `:leaf`
+            # (because the yield is behind a helper) does not silently fold it.
             :match
           ],
           "MatchData" => Set[
-            # Defensive entry mirroring the other catalogs.
-            # `match_init_copy` is already `:leaf` per the
-            # extractor (it copies the regs slot in place but
-            # uses no helper the C-body regex flags as a
-            # mutator); blocked so a future
-            # `Constant<MatchData>` carrier never folds an
-            # aliasing copy through the catalog.
+            # Defensive entry mirroring the other catalogs. `match_init_copy` is already `:leaf` per the
+            # extractor (it copies the regs slot in place but uses no helper the C-body regex flags as a
+            # mutator); blocked so a future `Constant<MatchData>` carrier never folds an aliasing copy
+            # through the catalog.
             :initialize_copy
           ]
         }

data/lib/rigor/inference/builtins/set_catalog.rb

@@ -7,41 +7,32 @@ module Rigor
     module Builtins
       # `Set` catalog. Singleton — load once, consult during dispatch.
       #
-      # Set was rewritten in C and folded into CRuby for Ruby 3.2+;
-      # the reference branch (`ruby_4_0`) ships the implementation in
-      # `references/ruby/set.c` with `Init_Set` registering every
-      # method directly. There is no `set.rb` prelude — the trailing
-      # `rb_provide("set.rb")` makes `require "set"` a no-op against
-      # the built-in.
+      # Set was rewritten in C and folded into CRuby for Ruby 3.2+; the reference branch (`ruby_4_0`)
+      # ships the implementation in `references/ruby/set.c` with `Init_Set` registering every method
+      # directly. There is no `set.rb` prelude — the trailing `rb_provide("set.rb")` makes `require "set"`
+      # a no-op against the built-in.
       #
-      # The blocklist below catches the catalog `:leaf` entries the
-      # C-body classifier mis-attributes. Set's iteration helpers
-      # (`set_iter`, `RETURN_SIZED_ENUMERATOR`) and its identity-
-      # mode and reset paths drive into helpers the regex classifier
-      # does not yet recognise as block-yielding or mutating.
+      # The blocklist below catches the catalog `:leaf` entries the C-body classifier mis-attributes.
+      # Set's iteration helpers (`set_iter`, `RETURN_SIZED_ENUMERATOR`) and its identity-mode and reset
+      # paths drive into helpers the regex classifier does not yet recognise as block-yielding or
+      # mutating.
       SET_CATALOG = MethodCatalog.for_topic(
         "set",
         mutating_selectors: {
           "Set" => Set[
-            # Indirect mutators classified `:leaf` because the C
-            # classifier did not follow the helper functions:
+            # Indirect mutators classified `:leaf` because the C classifier did not follow the helper
+            # functions:
             #
-            # - `initialize_copy` calls `set_copy` to overwrite the
-            #   receiver's table.
-            # - `compare_by_identity` swaps the internal hash type
-            #   via `set_reset_table_with_type`.
-            # - `reset` rebuilds the internal table to dedup after
-            #   element mutation.
+            # - `initialize_copy` calls `set_copy` to overwrite the receiver's table.
+            # - `compare_by_identity` swaps the internal hash type via `set_reset_table_with_type`.
+            # - `reset` rebuilds the internal table to dedup after element mutation.
             :initialize_copy, :compare_by_identity, :reset,
-            # Block-dependent methods classified `:leaf` because the
-            # C body uses `set_iter` / `RETURN_SIZED_ENUMERATOR`
-            # rather than calling `rb_yield` directly:
+            # Block-dependent methods classified `:leaf` because the C body uses `set_iter` /
+            # `RETURN_SIZED_ENUMERATOR` rather than calling `rb_yield` directly:
             :each, :classify, :divide,
-            # `disjoint?` delegates into `set_i_intersect`, which
-            # for non-Set enumerables uses `rb_funcall(other,
-            # :any?, ...)` — that is user-redefinable dispatch the
-            # classifier missed because the call site is in a
-            # sibling function.
+            # `disjoint?` delegates into `set_i_intersect`, which for non-Set enumerables uses
+            # `rb_funcall(other, :any?, ...)` — that is user-redefinable dispatch the classifier missed
+            # because the call site is in a sibling function.
             :disjoint?
           ]
         }

data/lib/rigor/inference/builtins/string_catalog.rb

@@ -5,16 +5,12 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `String` and `Symbol` catalog. Singleton — load once,
-      # consult during dispatch.
+      # `String` and `Symbol` catalog. Singleton — load once, consult during dispatch.
       #
-      # The blocklist below is the curated set of catalog `:leaf`
-      # entries the C-body classifier mis-attributes (the body of
-      # `rb_str_replace` calls `str_modifiable` / `str_discard`
-      # which the regex-based classifier does not recognise as
-      # mutation primitives). Adding to the blocklist is the
-      # corrective surface for false positives until the
-      # classifier learns the helper functions.
+      # The blocklist below is the curated set of catalog `:leaf` entries the C-body classifier
+      # mis-attributes (the body of `rb_str_replace` calls `str_modifiable` / `str_discard` which the
+      # regex-based classifier does not recognise as mutation primitives). Adding to the blocklist is the
+      # corrective surface for false positives until the classifier learns the helper functions.
       STRING_CATALOG = MethodCatalog.for_topic(
         "string",
         mutating_selectors: {
@@ -23,19 +19,16 @@ module Rigor
             :prepend, :force_encoding, :encode, :scrub, :unicode_normalize, :"[]=",
             :upto, :each_byte, :each_char, :each_codepoint,
             :each_grapheme_cluster, :each_line, :bytesplice,
-            # `crypt` is not a mutator but is blocked from folding for the
-            # same "do not bake a non-pure result into a Constant" reason:
-            # `rb_str_crypt` delegates to the platform `crypt(3)`, whose
-            # output (algorithm and digest) varies by libc / OS, so
-            # `"x".crypt("ab")` is not deterministic across the platforms
-            # an analyzed project may target. The catalog classifies it
-            # `:leaf` from its C body; this entry overrides that.
+            # `crypt` is not a mutator but is blocked from folding for the same "do not bake a non-pure
+            # result into a Constant" reason: `rb_str_crypt` delegates to the platform `crypt(3)`, whose
+            # output (algorithm and digest) varies by libc / OS, so `"x".crypt("ab")` is not deterministic
+            # across the platforms an analyzed project may target. The catalog classifies it `:leaf` from
+            # its C body; this entry overrides that.
             :crypt
           ],
           "Symbol" => Set[
-            # Symbol is immutable in Ruby; the classifier mis-flags
-            # `inspect` because `rb_sym_inspect` builds a temporary
-            # mutable buffer. Allow it.
+            # Symbol is immutable in Ruby; the classifier mis-flags `inspect` because `rb_sym_inspect`
+            # builds a temporary mutable buffer. Allow it.
           ]
         }
       )

data/lib/rigor/inference/builtins/struct_catalog.rb

@@ -5,44 +5,32 @@ require_relative "method_catalog"
 module Rigor
   module Inference
     module Builtins
-      # `Struct` catalog. Singleton — load once, consult during
-      # dispatch.
+      # `Struct` catalog. Singleton — load once, consult during dispatch.
       #
-      # `Struct` is a meta-class: `Struct.new(*members)` returns a
-      # fresh anonymous subclass — never a `Struct` value. Today
-      # Rigor never produces a `Constant<Struct>` carrier (a literal
-      # struct instance), so the catalog is defensive: it documents
-      # the shape and forbids unsafe folds in case a future tier
-      # learns to lift literal struct instances into the value
-      # lattice.
+      # `Struct` is a meta-class: `Struct.new(*members)` returns a fresh anonymous subclass — never a
+      # `Struct` value. Today Rigor never produces a `Constant<Struct>` carrier (a literal struct
+      # instance), so the catalog is defensive: it documents the shape and forbids unsafe folds in case a
+      # future tier learns to lift literal struct instances into the value lattice.
       #
-      # Subclasses define their own writers (`name=`) at class-build
-      # time, so per-instance member accessors do not appear in this
-      # YAML — only the generic `[]` / `[]=` pair on the base class.
-      # `[]=` is already classified `:mutates_self`; `[]` reads a
-      # member but the answer depends on the subclass's member
-      # definition, which the catalog does not see, so we blocklist
-      # it defensively.
+      # Subclasses define their own writers (`name=`) at class-build time, so per-instance member
+      # accessors do not appear in this YAML — only the generic `[]` / `[]=` pair on the base class. `[]=`
+      # is already classified `:mutates_self`; `[]` reads a member but the answer depends on the
+      # subclass's member definition, which the catalog does not see, so we blocklist it defensively.
       STRUCT_CATALOG = MethodCatalog.for_topic(
         "struct",
         mutating_selectors: {
           "Struct" => Set[
-            # Defensive: aliasing-copy semantics on a hypothetical
-            # `Constant<Struct>` carrier. Convention across the
-            # other catalogs (Range, Random, Pathname).
+            # Defensive: aliasing-copy semantics on a hypothetical `Constant<Struct>` carrier. Convention
+            # across the other catalogs (Range, Random, Pathname).
             :initialize_copy,
-            # `rb_struct_hash` mixes member values via
-            # `rb_hash` -> `rb_funcall(:hash, ...)`. The classifier
-            # sees no direct dispatch because the recursion goes
-            # through `rb_hash` (a helper), but the answer depends
-            # on the member values' `#hash` — user-redefinable.
-            # Block to avoid folding a hash that would diverge
-            # from the runtime once a member overrides `#hash`.
+            # `rb_struct_hash` mixes member values via `rb_hash` -> `rb_funcall(:hash, ...)`. The
+            # classifier sees no direct dispatch because the recursion goes through `rb_hash` (a helper),
+            # but the answer depends on the member values' `#hash` — user-redefinable. Block to avoid
+            # folding a hash that would diverge from the runtime once a member overrides `#hash`.
             :hash,
-            # `rb_struct_aref` reads a member by name or index; the
-            # answer depends on the subclass's member layout, which
-            # the catalog does not carry. Folding without knowing
-            # the layout would be unsound.
+            # `rb_struct_aref` reads a member by name or index; the answer depends on the subclass's
+            # member layout, which the catalog does not carry. Folding without knowing the layout would
+            # be unsound.
             :[]
           ]
         }