rigortype 0.4.6 → 0.4.8

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

@@ -148,7 +148,7 @@ module Rigor
 
         # Runs the actual reduction, guarded by the rescue harness and the magnitude cap. Empty-collection
         # semantics match Ruby: `[].reduce(s, :op) == s` (seed form) and `[].reduce(:op) == nil` (no-seed
-        # form → declines so the nominal fold's no-nil contract stands; see `fold_result`).
+        # form → declines so the nominal fold's no-nil contract stands; see the class comment).
         def execute_constant_reduce(members, operator, seed_value, seed_present)
           result =
             if seed_present

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

@@ -14,8 +14,8 @@ module Rigor
       # * `new(str)` / `new(str, opts)` — constructs a Regexp at fold time when the pattern argument is a
       #   `Constant[String]`. The optional second argument may be a `Constant[Integer]` (flag bits), a
       #   `Constant[true/false]` (IGNORECASE shorthand), or absent. Returns `Constant[Regexp]`.
-      # * `compile(str)` / `compile(str, opts)` — `Regexp.compile` is a documented alias of `Regexp.new`
-      #   (same C entry point, `rb_reg_s_new`); shares `fold_new` verbatim.
+      # * `compile(str)` / `compile(str, opts)` — `Regexp.compile` is a documented alias of `Regexp.new`;
+      #   shares `fold_new` verbatim.
       # * `union(*patterns)` / `union(array)` — builds the combined pattern at inference time when every
       #   element is a `Constant[String]` or `Constant[Regexp]`. Delegates to the real `Regexp.union` so the
       #   zero-arg (`/(?!)/`), single-array-argument, and pre-built-Regexp-argument forms all match Ruby's

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

@@ -67,8 +67,8 @@ module Rigor
           projected_self(class_name, receiver_args)
         end
 
-        # Nil when every argument widens to the bare `Dynamic[top]`: `Hash[untyped, untyped]` says nothing
-        # the raw `Hash` does not.
+        # Nil when every argument widens to untyped: a `Hash` of untyped keys and values says nothing the
+        # raw `Hash` does not.
         def projected_self(class_name, receiver_args)
           type_args = receiver_args.map { |arg| deep_widen(arg) }
           return nil if type_args.all? { |arg| untyped?(arg) }
@@ -104,7 +104,7 @@ module Rigor
         end
 
         def untyped?(type)
-          type.is_a?(Type::Dynamic) && type.static_facet.is_a?(Type::Top)
+          Type::Combinator.untyped?(type)
         end
 
         # `widen_value_pinned`, extended through nested shape carriers and applied type arguments.

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

@@ -13,17 +13,19 @@ module Rigor
       #
       # === Supported methods
       #
-      # * `Set[]` — variadic constructor; each argument must be a `Constant[T]`. Returns `Constant[Set]`.
+      # * `Set[]` — variadic constructor. Returns `Constant[Set]` when every argument is a `Constant[T]`, and a
+      #   typed `Set` otherwise.
       # * `Set.new` — zero-argument form; returns `Constant[Set.new]`.
-      # * `Set.new(tuple)` — the argument must be a `Tuple` whose every element is a `Constant[T]`. Returns
-      #   `Constant[Set]`.
+      # * `Set.new(tuple)` — a `Tuple` argument. Returns `Constant[Set]` when every element is a `Constant[T]`,
+      #   and a typed `Set` otherwise.
       #
       # === Non-constant / unsupported cases
       #
       # Returns `nil` (deferring to the next dispatcher tier) when:
       # - the receiver is not `Singleton[Set]`,
       # - the method is not `[]` or `new`,
-      # - any argument is non-constant or structurally opaque.
+      # - the call is splatted or carries a block, or its `new` argument is not a `Tuple` or an `Array` / `Set`
+      #   carrier.
       module SetFolding
         module_function
 
@@ -86,9 +88,9 @@ module Rigor
 
         # `Nominal[Set, [E]]`, `E` the members widened as an `Array.new` fill is (value pins dropped, a literal
         # container widened to its nominal) joined with a `Dynamic[top]` floor. The floor is the conservative half:
-        # nothing widens a Set's element when the program mutates it (`add`, `<<`, `merge`, `replace`, `clear`
-        # then `<<`, a callee that fills it), so the classes the set was built with are not a claim about what it
-        # holds later, and a read of the element must not report on them (#2278).
+        # the mutation seams ({SetMutation}, #2294) see one store at a time, so the classes the set was built with
+        # are not a claim about what it holds later, and a read of the element must not report on them (#2278). The
+        # floor is also what lets those seams re-grow the set.
         def typed_set(types)
           return nil if types.empty?