rigortype 0.4.5 → 0.4.7

data/lib/rigor/type/combinator.rb

@@ -245,8 +245,8 @@ module Rigor
       end
 
       # `literal-string` — a `String` that is statically known to come from a source-code literal (or a
-      # composition of literals). v0.0.9 tracks this flow through interpolation `"#{...}"`, leaving
-      # propagation through `+` / `<<` to a later slice. Every `Constant<String>` is implicitly
+      # composition of literals). Interpolation `"#{...}"` and `+` / `*` composition keep
+      # the flow (see {literal_string_compatible?}). Every `Constant<String>` is implicitly
       # literal-string-compatible; the carrier exists for cases where the concrete value is unknown but
       # literal-ness has been established (an RBS::Extended `return: literal-string` annotation, or
       # interpolation over literal-bearing parts).
@@ -433,8 +433,7 @@ module Rigor
       # - `Type::Tuple[A, B, C]` → `Constant<0> | Constant<1> | Constant<2>`.
       # - `Type::Nominal["Hash", [K, V]]` → `K` (untyped if absent).
       # - `Type::Nominal["Array", [E]]` → `non-negative-int`.
-      # - `Type::Constant` whose value is a Hash / Array / Range — project through the literal's
-      #   per-element keys.
+      # - `Type::Constant` wrapping a Range with an Integer begin — `non-negative-int`.
       #
       # Other inputs (`Top`, `Dynamic`, untyped Nominals, `Union`, `Refined`, `Difference`,
       # `Intersection`) project to `top` so the type function always returns a value — callers may narrow
@@ -456,8 +455,7 @@ module Rigor
       # - `Type::Tuple[A, B, C]` → `A | B | C`.
       # - `Type::Nominal["Hash", [K, V]]` → `V` (untyped if absent).
       # - `Type::Nominal["Array", [E]]` → `E` (untyped if absent).
-      # - `Type::Constant` whose value is a Hash / Array / Range — union of `Constant<…>` for each
-      #   element.
+      # - `Type::Constant` wrapping an integer Range — the `IntegerRange` it spans.
       def value_of(type)
         case type
         when HashShape then hash_shape_values(type)
@@ -528,8 +526,7 @@ module Rigor
       # Phase A handles `Type::HashShape` (literal-key K). Phase B (slice 5) extends to `Type::Tuple`
       # (integer-index K) — `pick_of[Tuple[A, B, C], 0 | 2]` evaluates to `Tuple[A, C]`. Non-shape inputs
       # (`Type::Nominal`, etc.) return `type` unchanged ("lossy degradation"; the
-      # `dynamic.shape.lossy-projection` diagnostic that flags the boundary lands when caller-side
-      # diagnostic threading arrives).
+      # `dynamic.shape.lossy-projection` diagnostic that flags the boundary).
       def pick_of(type, keys)
         case type
         when HashShape then hash_shape_pick(type, keys)
@@ -597,8 +594,7 @@ module Rigor
       # site where the projection was authored.
       #
       # `HashShape` and `Tuple` carry shape-level information the projections honour; every other carrier
-      # is lossy. Slice 5b wires diagnostic emission through `RbsExtended` / parser callers; this
-      # predicate stands alone in slice 5 for unit-test coverage and future composition.
+      # is lossy.
       def shape_projection_lossy?(type)
         !type.is_a?(HashShape) && !type.is_a?(Tuple)
       end
@@ -792,9 +788,9 @@ module Rigor
           top
         end
 
-        # `Type::Constant` only carries scalar literals (Integer / Float / String / Symbol / Range /
-        # Rational / Complex / true / false / nil); Array and Hash literals become Tuple / HashShape
-        # carriers earlier in the typer. Range is the only scalar with meaningful key/value projections.
+        # `Type::Constant` only carries scalar literals (`Constant::SCALAR_CLASSES`); Array and Hash literals
+        # become Tuple / HashShape carriers earlier in the typer. Range is the only scalar with meaningful
+        # key/value projections.
         def constant_keys(value)
           return non_negative_int if value.is_a?(Range) && value.begin.is_a?(Integer)
 
@@ -1040,9 +1036,10 @@ module Rigor
         # No type carrier has a method that changes it once built (a built type is frozen; one `Marshal.load`
         # restores is not, but nothing mutates it either), so a memoised key cannot go stale. The memo is weak
         # in both key and value: it keeps neither the type nor the string alive, and an entry whose string
-        # nothing else holds is dropped at the next GC. It is keyed by identity on purpose: `Constant[0.0]` and
-        # `Constant[-0.0]` are equal and hash alike, but render differently. A non-main Ractor may not read the
-        # module's ivar, so a pool worker renders the key every time, as every run did before.
+        # nothing else holds is dropped at the next GC. It is keyed by identity on purpose: two equal members
+        # need not render alike (`Constant[1..2]` and `Constant[1..2.0]`), so equality is not a safe key. A
+        # non-main Ractor may not read the module's ivar, so a pool worker renders the key every time, as every
+        # run did before.
         def sort_key(member)
           return member.describe(:short) unless Ractor.main?
 

data/lib/rigor/type/constant.rb

@@ -8,9 +8,8 @@ require_relative "plain_lattice"
 module Rigor
   module Type
     # A literal carrier under ADR-3 OQ1 Option C (Hybrid). Wraps a Ruby literal value of one of the
-    # supported immutable-ish classes. Compound literal shapes (Tuple, HashShape, Record) get dedicated
-    # classes in later slices; Range is carried only when both static endpoints are known enough for
-    # tuple slicing.
+    # supported immutable-ish classes. Compound literal shapes (Tuple, HashShape) have their own classes;
+    # Range is carried only when both static endpoints are known enough for tuple slicing.
     #
     # See docs/adr/4-type-inference-engine.md for the tentative answer to the open question and
     # docs/type-specification/rigor-extensions.md for the refinement neighbourhood this carrier lives in.
@@ -74,12 +73,15 @@ module Rigor
 
       # RBS supports `Literal` types for booleans, nil, integer literals (positive and negative), symbol
       # literals, and string literals. Erasing to these preserves the carrier's precision at the RBS
-      # boundary — `Constant<64>` round-trips as `64`, not as `Integer` — and
+      # boundary — the constant 64 round-trips as `64`, not as `Integer` — and
       # `RbsTypeTranslator#translate_literal` already maps the parsed RBS Literal back to `Constant`.
       # Scalar carriers without RBS Literal support (Float, Range, Rational, Complex, Regexp, Pathname)
       # keep their pre-existing widen-to-class-name behaviour because RBS rejects their literal spellings
       # as syntax errors. `Range` is generic (`Range[out E]`), and a bare `Range` fails `rbs validate`, so
-      # it carries the class of its endpoints, or `untyped` when both are nil (#1891).
+      # it carries the class of its endpoints, or `untyped` when both are nil (#1891). `Set` is
+      # generic too, and a set is mutable: the constant's elements are only what it held when it was built, and
+      # `x << "a"` adds a member they do not name. It erases to `Set[untyped]`, as an Array or Hash literal's
+      # element type is widened rather than pinned (#2177).
       def erase_to_rbs
         case value
         when true then "true"
@@ -88,6 +90,7 @@ module Rigor
         when Integer then value.to_s
         when Symbol, String then value.inspect
         when Range then "Range[#{range_element_rbs}]"
+        when ::Set then "Set[untyped]"
         else value.class.name
         end
       end
@@ -96,13 +99,51 @@ module Rigor
 
       include Rigor::Type::AcceptanceRouter
 
+      # Two carriers are equal when they pin the same value, which for a Float is stricter than Ruby's `==`
+      # (#1513): `0.0` and `-0.0` are distinct values (`1.0 / x` tells them apart), so `0.0 | -0.0` keeps both
+      # members, and a NaN equals another NaN, so `==` stays reflexive and a union never collects one NaN member
+      # per occurrence. A Complex compares its parts the same way.
       def ==(other)
-        other.is_a?(Constant) && value.class == other.value.class && value == other.value
+        other.is_a?(Constant) && value.class == other.value.class && Constant.same_value?(value, other.value)
       end
       alias eql? ==
 
       def hash
-        [Constant, value.class, value].hash
+        [Constant, value.class, Constant.value_key(value)].hash
+      end
+
+      # True when `left` and `right` (of one class) are the same value in the sense of {#==}.
+      def self.same_value?(left, right)
+        case left
+        when Float then same_float?(left, right)
+        when Complex then same_float?(left.real, right.real) && same_float?(left.imaginary, right.imaginary)
+        else left == right
+        end
+      end
+
+      def self.same_float?(left, right)
+        return left == right unless left.is_a?(Float) && right.is_a?(Float)
+        return right.nan? if left.nan?
+
+        left.eql?(right) && (!left.zero? || (1.0 / left).positive? == (1.0 / right).positive?)
+      end
+
+      # A key whose `eql?` / `hash` agree with {.same_value?}: `uniq { |v| Constant.value_key(v) }` keeps
+      # `0.0` and `-0.0` apart and folds every NaN into one. Any other value is its own key, so plain `uniq`
+      # semantics are unchanged for it.
+      def self.value_key(value)
+        case value
+        when Float then float_key(value)
+        when Complex then [Complex, float_key(value.real), float_key(value.imaginary)]
+        else value
+        end
+      end
+
+      def self.float_key(value)
+        return value unless value.is_a?(Float)
+        return :nan if value.nan?
+
+        value.zero? ? [Float, (1.0 / value)] : value
       end
 
       def inspect

data/lib/rigor/type/hash_shape.rb

@@ -28,14 +28,14 @@ module Rigor
       ALLOWED_KEY_CLASSES = [Symbol, String, Integer, Float, TrueClass, FalseClass, NilClass].freeze
       EXTRA_KEY_POLICIES = %i[open closed].freeze
       POLICY_KEYWORDS = %i[required_keys optional_keys read_only_keys extra_keys].freeze
-      # A Symbol whose text matches renders as a bare RBS record key (`lang:`) in {#erase_to_rbs};
-      # anything else must be quoted with a fat arrow (`"data-contrast" =>`). See {#erase_key_prefix}.
+      # A Symbol whose text matches renders as a bare RBS record key (`lang:`) in {#describe} and {#erase_to_rbs};
+      # anything else is a quoted Symbol with a fat arrow (`:"data-contrast" =>`). See {#key_prefix}.
       BARE_RECORD_KEY = /\A[A-Za-z_][A-Za-z0-9_]*[?!]?\z/
 
       attr_reader :pairs, :required_keys, :optional_keys, :read_only_keys, :extra_keys
 
       # @param pairs — ordered map of
-      #   keys to declared types. Keys MUST be Symbol or String;
+      #   keys to declared types. Keys MUST be one of ALLOWED_KEY_CLASSES;
       #   values MUST be Rigor::Type instances. The hash is duped and
       #   frozen at construction; callers MUST NOT mutate the input
       #   afterwards (mutation does not affect the carrier, but the
@@ -72,9 +72,9 @@ module Rigor
       def erase_to_rbs
         return "{}" if pairs.empty? && closed?
         return hash_erasure unless closed?
-        return hash_erasure if pairs.each_key.any? { |k| !k.is_a?(Symbol) }
+        return hash_erasure if pairs.each_key.any? { |k| !k.is_a?(Symbol) || !record_key_spellable?(k) }
 
-        rendered = pairs.map { |k, v| "#{erase_key_prefix(k)} #{v.erase_to_rbs}" }
+        rendered = pairs.map { |k, v| "#{key_prefix(k)} #{v.erase_to_rbs}" }
         "{ #{rendered.join(', ')} }"
       end
 
@@ -193,47 +193,33 @@ module Rigor
       def render_entry(key, value, verbosity)
         prefix = []
         prefix << "readonly" if read_only_key?(key)
-        rendered_key = optional_key?(key) ? "?#{render_key(key)}" : render_key(key)
-        prefix << "#{rendered_key}#{key_separator(key)}"
+        prefix << key_prefix(key)
         "#{prefix.join(' ')} #{value.describe(verbosity)}"
       end
 
-      # `describe` is a human-facing display contract (it feeds diagnostic messages, never a parser),
-      # so it keeps the compact `"a":` form for a quoted key. Non-(Symbol|String) scalar keys render in
-      # the natural hashrocket spelling (`1 => 2`, `1.0 => 4`, `nil => 0`) via {#key_separator}; their
-      # `inspect` is the canonical Ruby literal, so describe stays deterministic. The RBS-erasure path
-      # uses {#erase_key_prefix} instead, which must emit a parseable key.
-      def render_key(key)
-        case key
-        when Symbol then key.to_s
-        else key.inspect
-        end
-      end
+      # A key and its separator as RBS spells them, with a leading `?` for an optional key. `describe`
+      # (the diagnostic display) and {#erase_to_rbs} (which only ever sees Symbol keys — string-keyed
+      # shapes degrade to `Hash[...]` before reaching here) share it, so a key reads the same in a
+      # message as in the signature it erases to. A Symbol whose text is a plain identifier is a bare
+      # key with a colon (`lang:`, Ruby keywords like `class` included). Any other Symbol is a quoted
+      # Symbol literal with a fat arrow (`:"data-contrast" =>`): RBS rejects a bare non-identifier
+      # (`data-contrast:`) and a quoted key with a colon (`"data-contrast":`), and reads
+      # `"data-contrast" =>` as the String key, so the written record declared a key the body never has
+      # (#2176). Every other key, a String included, is its `inspect` literal with a fat arrow
+      # (`"a-b" =>`, `1 =>`, `nil =>`): the compact `"a-b":` would read as a Symbol key in Ruby, so a
+      # String-vs-Symbol key mismatch in a diagnostic was unreadable (#2235).
+      def key_prefix(key)
+        optional = optional_key?(key) ? "?" : ""
+        return "#{optional}#{key.inspect} =>" unless key.is_a?(Symbol)
+        return "#{optional}#{key}:" if BARE_RECORD_KEY.match?(key.to_s)
 
-      # Symbol / String keys keep the compact colon form (`a: 1`, `"k": 2`); every other scalar key uses
-      # the hashrocket (`1 => 2`) — the form the user would have to write in source.
-      def key_separator(key)
-        case key
-        when Symbol, String then ":"
-        else " =>"
-        end
+        "#{optional}:#{key.to_s.inspect} =>"
       end
 
-      # An RBS record entry's key + separator, for the {#erase_to_rbs} path (which only ever sees
-      # Symbol keys — string-keyed shapes degrade to `Hash[...]` before reaching here). A Symbol whose
-      # text is a plain identifier is a bare key with a colon (`lang:`); a hyphenated / punctuated
-      # Symbol MUST use the quoted `"data-contrast" =>` form, because RBS rejects both a bare
-      # non-identifier (`data-contrast:`) and a quoted key with a colon (`"data-contrast":`). Getting
-      # this wrong made sig-gen emit an unparseable Mastodon `html_attributes` shape that crashed the
-      # whole RBS env build. Valid identifier keys (incl. Ruby keywords like `class`) keep the colon
-      # form, so only genuinely non-identifier keys change. Optional keys carry a leading `?`.
-      def erase_key_prefix(key)
-        optional = optional_key?(key) ? "?" : ""
-        if BARE_RECORD_KEY.match?(key.to_s)
-          "#{optional}#{key}:"
-        else
-          "#{optional}#{key.to_s.inspect} =>"
-        end
+      # `String#inspect` escapes `#{`, `#$` and `#@` as `\#`, which RBS's parser does not read back as
+      # `#`. A key spelled that way would name a different Symbol, so the shape erases to `Hash[...]`.
+      def record_key_spellable?(key)
+        !key.to_s.inspect.include?("\\#")
       end
 
       def hash_erasure

data/lib/rigor/type/struct_instance.rb

@@ -63,10 +63,11 @@ module Rigor
       end
 
       # Erases to the tagging class nominal (conservative: the structural members are not RBS-expressible
-      # as a class instance). The anonymous case erases to the `Struct` supertype.
+      # as a class instance). The anonymous case erases to the `Struct` supertype with an `untyped`
+      # element: `Struct[Elem]` is generic, and a bare `Struct` fails `rbs validate` (#2177).
       def erase_to_rbs
         name = class_name
-        return "Struct" if name.nil?
+        return "Struct[untyped]" if name.nil?
 
         name
       end

data/lib/rigor/type/union.rb

@@ -49,7 +49,7 @@ module Rigor
         end
       end
 
-      # ADR-1 § "RBS round-trip is lossless" + the value-lattice rule `untyped | T = untyped` (every `T`
+      # ADR-1 § "Erasure Must Be Conservative" + the value-lattice rule `untyped | T = untyped` (every `T`
       # is gradually consistent with `untyped`). When any union member erases to `"untyped"`, the whole
       # union erases to `"untyped"` — the RBS surface has no carrier for "Dynamic-origin alongside a
       # static facet", and the gradual-consistency contract guarantees the substitution is sound at every

data/lib/rigor/type_node/identifier.rb

@@ -22,8 +22,7 @@ module Rigor
         # Freeze the String field so the resulting Data object is `Ractor.shareable?` regardless of
         # whether the caller passed a `# frozen_string_literal: true` constant or a dynamically built
         # String. The same discipline applies to every other TypeNode value object — they live in the
-        # parser's hot path and are the natural carriers to flow through future Ractor boundaries
-        # (see CURRENT_WORK Open Items #8).
+        # parser's hot path and are the natural carriers to flow through future Ractor boundaries.
         super(name: name.frozen? ? name : name.dup.freeze)
       end
     end

data/lib/rigor/type_node/resolver_chain.rb

@@ -16,7 +16,7 @@ module Rigor
     # resolver in the chain plus the built-in registry through the
     # same entry point.
     #
-    # Constructed once per `Analysis::Runner.run` from
+    # Built by `Environment#build_name_scope` from
     # `Plugin::Registry#type_node_resolvers`. The chain is
     # immutable and re-entrant; the parser may consult it many
     # times for the same node.

data/lib/rigor/type_node/string_literal.rb

@@ -7,8 +7,7 @@ module Rigor
     # `Pick[T, "name"]`, `pick_of[Shape, "a" | "b"]`, and downstream
     # plugin resolvers that accept literal key selectors.
     #
-    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
-    # #2): the RBS::Extended grammar previously could not tokenise
+    # ADR-13 follow-up: the RBS::Extended grammar previously could not tokenise
     # `"name"` inside a type-arg position. The resolver translates
     # this node to a `Type::Constant` carrying the string value.
     # Slice 1 supports double-quoted strings without escape

data/lib/rigor/type_node/symbol_literal.rb

@@ -7,8 +7,7 @@ module Rigor
     # `Pick[T, :name]`, `pick_of[Shape, :a | :b]`, and downstream
     # plugin resolvers that accept literal key selectors.
     #
-    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
-    # #2): the RBS::Extended grammar previously could not tokenise
+    # ADR-13 follow-up: the RBS::Extended grammar previously could not tokenise
     # `:name` inside a type-arg position; this addition closes the
     # gap so `ImportedRefinements.parse` produces a uniform AST.
     # The resolver translates this node to a `Type::Constant`

data/lib/rigor/type_node/union.rb

@@ -5,8 +5,7 @@ module Rigor
     # Union AST node. Carries the nodes of a `T1 | T2 | …` union
     # expression authored at type-arg position.
     #
-    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
-    # #2): together with {SymbolLiteral} / {StringLiteral} this
+    # ADR-13 follow-up: together with {SymbolLiteral} / {StringLiteral} this
     # closes the parser-side gap that prevented `Pick[T, :a | :b]`
     # / `Pick[T, "a" | "b"]` from tokenising. The resolver pass
     # recurses through each node and folds them via
@@ -16,10 +15,8 @@ module Rigor
     # shadowing `Data#members`, which is the introspection method
     # every `Data.define` mix-in inherits.
     #
-    # Nodes are themselves any of the {TypeNode} carriers — the
-    # parser builds a flat list (left-associative); nested
-    # `Union` nodes are permitted but the parser does not
-    # synthesise them by itself.
+    # The parser builds a flat list (left-associative); the constructor
+    # rejects a nested `Union` node.
     class Union < Data.define(:nodes)
       def initialize(nodes:)
         unless nodes.is_a?(Array) && nodes.size >= 2 && nodes.all? { |m| valid_member?(m) }

data/lib/rigor/value_semantics.rb

@@ -46,16 +46,7 @@ module Rigor
         key = (["self.class"] + fields.map(&:to_s)).join(", ")
 
         # Codegen (not per-call reflection) so the generated `==` / `hash` read fields
-        # directly and run at hand-written speed on the inference hot path. For
-        # `value_fields :class_name, :type_args` the emitted source is:
-        #
-        #   def ==(other)
-        #     other.is_a?(self.class) && class_name == other.class_name && type_args == other.type_args
-        #   end
-        #   alias_method :eql?, :==
-        #   def hash
-        #     [self.class, class_name, type_args].hash
-        #   end
+        # directly and run at hand-written speed on the inference hot path.
         class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
           def ==(other)
             other.is_a?(self.class)#{guard}

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.4.5"
+  VERSION = "0.4.7"
 end

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_discoverer.rb

@@ -167,8 +167,8 @@ module Rigor
         end
 
         # Walks the channel body recursively (so `stream_from` / `stream_for` calls inside `subscribed`
-        # / helper methods are picked up). Returns `[Array<String>, bool]` — the literal stream names +
-        # whether any dynamic registration was seen.
+        # / helper methods are picked up). Returns the literal stream names and whether any dynamic
+        # registration was seen, as a pair.
         def collect_stream_registrations(node, names: [], dynamic: false)
           return [names, dynamic] if node.nil?
 

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_index.rb

@@ -11,8 +11,8 @@ module Rigor
       #   `subscription.perform("action_name", data)`.
       # - `stream_names` — the set of literal-string stream names registered via `stream_from "name"`
       #   calls inside the channel body. Dynamic registrations (`stream_from interpolated_string`) are
-      #   recorded separately as `dynamic_streams: true` so the analyzer can suppress unknown-stream
-      #   warnings on any channel that has at least one dynamic registration.
+      #   recorded separately as `dynamic_streams: true`; when any channel has one, the analyzer suppresses
+      #   unknown-stream warnings for the whole run.
       class ChannelIndex
         Entry = Data.define(:class_name, :file_path, :action_methods, :stream_names, :dynamic_streams) do
           def includes_action?(name)
@@ -59,7 +59,6 @@ module Rigor
           @by_name.keys
         end
 
-        # All literal stream names registered across every discovered channel.
         def all_stream_names
           @entries.flat_map { |e| e.stream_names.to_a }.to_set
         end

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable.rb

@@ -12,7 +12,7 @@ module Rigor
     # rigor-actioncable — validates ActionCable `<Channel>.broadcast_to(...)` and
     # `ActionCable.server.broadcast(stream_name, ...)` call sites against the discovered channel index.
     #
-    # Tier 3F of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
+    # Tier 3F of the [Rails plugins roadmap](../../../../../docs/design/20260508-rails-plugins-roadmap.md).
     # Statically discovers channel classes by walking `channel_search_paths` and parsing each file with
     # Prism — no `actioncable` runtime dependency.
     #