rigortype 0.3.8 → 0.3.9

data/lib/rigor/source/node_locator.rb

@@ -22,25 +22,19 @@ module Rigor
       class OutOfRangeError < StandardError; end
 
       class << self
-        # @param source [String]
-        # @param root [Prism::Node]
-        # @param line [Integer] 1-indexed line number
-        # @param column [Integer] 1-indexed column number (byte index within the line)
-        # @return [Prism::Node, nil]
+        # @param line — 1-indexed line number
+        # @param column — 1-indexed column number (byte index within the line)
         def at_position(source:, root:, line:, column:)
           new(source: source, root: root).at_position(line: line, column: column)
         end
 
-        # @param root [Prism::Node]
-        # @param offset [Integer] 0-indexed byte offset
-        # @return [Prism::Node, nil]
+        # @param offset — 0-indexed byte offset
         def at_offset(root:, offset:)
           new(source: nil, root: root).at_offset(offset)
         end
       end
 
-      # @param source [String, nil] used by `#at_position`; may be omitted when only `#at_offset` is needed.
-      # @param root [Prism::Node]
+      # @param source — used by `#at_position`; may be omitted when only `#at_offset` is needed.
       def initialize(source:, root:)
         @source = source
         @root = root
@@ -48,7 +42,7 @@ module Rigor
 
       # Resolve a `(line, column)` pair (1-indexed) to the deepest enclosing node.
       #
-      # @raise [OutOfRangeError] if the line or column falls outside the source buffer.
+      # @raise OutOfRangeError — if the line or column falls outside the source buffer.
       def at_position(line:, column:)
         offset = position_to_offset(line, column)
         at_offset(offset)

data/lib/rigor/source/node_walker.rb

@@ -25,8 +25,7 @@ module Rigor
     module NodeWalker
       module_function
 
-      # @yieldparam node [Prism::Node]
-      # @return [Enumerator] when no block is given.
+      # @return when no block is given.
       def each(root, &)
         return to_enum(__method__, root) unless block_given?
 
@@ -48,9 +47,7 @@ module Rigor
       # block invocation MUST copy it (`Plugin::NodeContext` does). Used by the plugin engine to give
       # `node_rule` blocks their enclosing class / method / block context (ADR-37 slice 1d).
       #
-      # @yieldparam node [Prism::Node]
-      # @yieldparam ancestors [Array<Prism::Node>]
-      # @return [Enumerator] when no block is given.
+      # @return when no block is given.
       def each_with_ancestors(root, &)
         return to_enum(__method__, root) unless block_given?
 

data/lib/rigor/triage/catalogue.rb

@@ -91,9 +91,7 @@ module Rigor
       INFO_GUARDED = %i[h5_systemic_cluster h6_genuine_bugs].freeze
       private_constant :INFO_GUARDED
 
-      # @param diagnostics [Array<Analysis::Diagnostic>]
-      # @param include_info [Boolean] let H5/H6 see `:info` diagnostics
-      # @return [Array<Hint>]
+      # @param include_info — let H5/H6 see `:info` diagnostics
       def recognise(diagnostics, include_info: false)
         claimed = {}.compare_by_identity
         recognisers.filter_map do |recogniser|

data/lib/rigor/triage.rb

@@ -34,11 +34,9 @@ module Rigor
     # `rbs.coverage.missing-gem`) survives; the count-based H5/H6 recognisers guard against info themselves so
     # recognition trace never reads as a bug.
     #
-    # @param diagnostics [Array<Analysis::Diagnostic>]
-    # @param top [Integer] hotspot-file cap
-    # @param hints [Boolean] run the heuristic catalogue
-    # @param include_info [Boolean] route info into the volume views
-    # @return [Report]
+    # @param top — hotspot-file cap
+    # @param hints — run the heuristic catalogue
+    # @param include_info — route info into the volume views
     def analyze(diagnostics, top: 10, hints: true, include_info: false)
       routed = include_info ? diagnostics : diagnostics.reject { |d| d.severity == :info }
       Report.new(

data/lib/rigor/type/accepts_result.rb

@@ -26,9 +26,8 @@ module Rigor
 
       attr_reader :trinary, :mode, :reasons
 
-      # @param trinary [Rigor::Trinary]
-      # @param mode [Symbol] currently `:gradual` (default) or `:strict`.
-      # @param reasons [Array<String>, String, nil] textual reasons; a
+      # @param mode — currently `:gradual` (default) or `:strict`.
+      # @param reasons — textual reasons; a
       #   single string is wrapped, `nil` becomes an empty array.
       def initialize(trinary, mode: :gradual, reasons: nil)
         raise ArgumentError, "trinary must be Rigor::Trinary, got #{trinary.class}" unless trinary.is_a?(Trinary)
@@ -42,18 +41,37 @@ module Rigor
 
       class << self
         def yes(mode: :gradual, reasons: nil)
-          new(Trinary.yes, mode: mode, reasons: reasons)
+          literal_result(Trinary.yes, mode, reasons)
         end
 
         def no(mode: :gradual, reasons: nil)
-          new(Trinary.no, mode: mode, reasons: reasons)
+          literal_result(Trinary.no, mode, reasons)
         end
 
         def maybe(mode: :gradual, reasons: nil)
-          new(Trinary.maybe, mode: mode, reasons: reasons)
+          literal_result(Trinary.maybe, mode, reasons)
+        end
+
+        private
+
+        # #775 — a result is an immutable value, so one instance serves every site that asks for the same
+        # verdict with the same literal reason (`"structural equality"`, `"exact name match"`, ...): the
+        # acceptance rules answer ~360k times on the lib self-check, most of them through a handful of
+        # such literals, and each answer cost the result plus its reasons array. A reason built at the
+        # site (an unfrozen interpolated String) or a reason list still builds a fresh result.
+        def literal_result(trinary, mode, reasons)
+          literal = reasons.nil? || (reasons.is_a?(String) && reasons.frozen?)
+          return new(trinary, mode: mode, reasons: reasons) unless literal
+
+          by_mode = (@literal_results[trinary] ||= {})
+          by_reason = (by_mode[mode] ||= {})
+          by_reason[reasons] ||= new(trinary, mode: mode, reasons: reasons)
         end
       end
 
+      # `Trinary` verdict => mode => literal reason (or nil) => the shared result.
+      @literal_results = {}
+
       def yes?
         trinary.yes?
       end

data/lib/rigor/type/combinator.rb

@@ -7,6 +7,7 @@ require_relative "nominal"
 require_relative "singleton"
 require_relative "constant"
 require_relative "integer_range"
+require_relative "float_range"
 require_relative "tuple"
 require_relative "hash_shape"
 require_relative "data_class"
@@ -60,7 +61,7 @@ module Rigor
       # list of Rigor::Type values that carry the receiver's generic instantiation (`Array[Integer]` is
       # `Nominal["Array", [Nominal["Integer"]]]`). Omitting the keyword produces the raw form
       # `Nominal["Array"]`, which is structurally distinct from any applied form.
-      def nominal_of(class_name_or_object, type_args: [])
+      def nominal_of(class_name_or_object, type_args: Nominal::EMPTY_TYPE_ARGS)
         Nominal.new(resolve_class_name(class_name_or_object), type_args)
       end
 
@@ -68,8 +69,16 @@ module Rigor
         Singleton.new(resolve_class_name(class_name_or_object))
       end
 
+      # #775 — `nil`, `true` and `false` are interned: a Constant is an immutable value, and these three
+      # are built on every optional translation, nil check and predicate fold (~200k of the ~210k Constant
+      # constructions on the lib self-check), so one shared instance each is unobservable and free.
       def constant_of(value)
-        Constant.new(value)
+        case value
+        when nil then NIL_CONSTANT
+        when true then TRUE_CONSTANT
+        when false then FALSE_CONSTANT
+        else Constant.new(value)
+        end
       end
 
       # Widens every value-pinned (`Constant`) constituent of `type` to its nominal base (`Constant[1]` ->
@@ -87,9 +96,11 @@ module Rigor
           # rather than flooring to `Dynamic[top]` (ADR-56).
           widen_value_pinned(type.base)
         when IntegerRange
-          # `int<1, 6>` is likewise a value-narrowed `Integer` (it erases to `Integer` in RBS); widen it
+          # `Integer[1..6]` is likewise a value-narrowed `Integer` (it erases to `Integer` in RBS); widen it
           # so a bounded-int accumulator converges (ADR-56).
           nominal_of("Integer")
+        when FloatRange
+          nominal_of("Float")
         when Union
           union(*type.members.map { |member| widen_value_pinned(member) })
         else
@@ -131,6 +142,23 @@ module Rigor
         IntegerRange.new(IntegerRange::NEG_INFINITY, IntegerRange::POS_INFINITY)
       end
 
+      # ADR-109 WD4 — `Float[min..max]` / `Float[min...max]`. Bounds are non-NaN Floats; the infinities
+      # are ordinary bounds. Raises on an empty range (the payload builder declines before reaching
+      # here).
+      def float_range(min, max, exclude_end: false)
+        FloatRange.new(min, max, exclude_end: exclude_end)
+      end
+
+      # Every Float except NaN: `Float[-Float::INFINITY..]`.
+      def non_nan_float
+        FloatRange.new(-Float::INFINITY, Float::INFINITY)
+      end
+
+      # Every Float except NaN and the infinities: `Float[-Float::MAX..Float::MAX]`.
+      def finite_float
+        FloatRange.new(-Float::MAX, Float::MAX)
+      end
+
       # Point-removal refinement carrier (ADR-3 OQ3 Option C). Use `non_empty_string` / `non_zero_int` /
       # `non_empty_array` / `non_empty_hash` for the imported built-in shapes; raw `difference(base,
       # removed)` for ad-hoc refinements an `RBS::Extended` annotation introduces.
@@ -382,6 +410,13 @@ module Rigor
       # Normalized union. Flattens nested Unions, deduplicates structurally equal members, drops Bot, and
       # collapses 0/1-member results.
       def union(*types)
+        # #775 — the same carrier on both sides of a join is already its own union. With the closed-alias
+        # translation memo every `Rigor::Type::t` reader shares one 21-member Union, so a control-flow join of
+        # an untouched binding would otherwise re-flatten and re-unique 42 members to rebuild an equal object.
+        # `rigor trace` still sees the merge (the tracer records degenerate merges).
+        first = types.first
+        return first if types.size == 2 && first.equal?(types[1]) && !Inference::FlowTracer.active?
+
         result = collapse_union(normalized_union_members(types))
         if Inference::BudgetTrace.enabled? && result.is_a?(Union)
           Inference::BudgetTrace.observe(Inference::BudgetTrace::UNION_ARITY, result.members.size)
@@ -790,12 +825,35 @@ module Rigor
 
           return [top] if flattened.any?(Top)
 
-          unique_members(flattened)
+          absorb_float_ranges(unique_members(flattened))
+        end
+
+        # ADR-109 WD5 — a `FloatRange` member is absorbed by a bare `Nominal[Float]` member or by a
+        # `FloatRange` member that contains it. The truthy edge of `x > c` is a range and the falsy
+        # edge keeps `Float`, so the join after every Float guard would otherwise carry both and every
+        # later guard would narrow member by member into a growing union (`Float[...1.0] |
+        # Float[0.0...1.0]`) that names one set. `IntegerRange` keeps its pre-ADR-109 behaviour
+        # (`Integer | Integer[0..5]` stays as written) because both of its edges narrow.
+        def absorb_float_ranges(members)
+          return members unless members.any?(FloatRange)
+
+          members.reject do |member|
+            member.is_a?(FloatRange) &&
+              members.any? { |other| !other.equal?(member) && float_range_absorbed_by?(member, other) }
+          end
+        end
+
+        def float_range_absorbed_by?(range, other)
+          case other
+          when Nominal then other.class_name == "Float" && other.type_args.empty?
+          when FloatRange then other != range && other.accepts(range).yes?
+          else false
+          end
         end
 
         def unique_members(types)
           types.each_with_object([]) do |type, unique|
-            unique << type unless unique.any? { |member| member == type }
+            unique << type unless unique.any? { |member| member.equal?(type) || member == type }
           end
         end
 
@@ -864,6 +922,11 @@ module Rigor
 
       # Eager-allocated at load time; see `untyped` method comment above.
       @untyped = Dynamic.new(Top.instance)
+
+      NIL_CONSTANT = Constant.new(nil)
+      TRUE_CONSTANT = Constant.new(true)
+      FALSE_CONSTANT = Constant.new(false)
+      private_constant :NIL_CONSTANT, :TRUE_CONSTANT, :FALSE_CONSTANT
     end
   end
 end

data/lib/rigor/type/data_class.rb

@@ -24,8 +24,8 @@ module Rigor
     class DataClass
       attr_reader :members, :class_name
 
-      # @param members [Array<Symbol>] ordered member names.
-      # @param class_name [String, nil] the bound class name, or nil for
+      # @param members — ordered member names.
+      # @param class_name — the bound class name, or nil for
       #   the anonymous `Data.define(...)` result.
       def initialize(members, class_name = nil)
         unless members.is_a?(Array) && members.all?(Symbol)

data/lib/rigor/type/data_instance.rb

@@ -27,9 +27,9 @@ module Rigor
     class DataInstance
       attr_reader :members, :class_name
 
-      # @param members [Hash{Symbol => Rigor::Type}] ordered member -> type
+      # @param members — ordered member -> type
       #   map. Every declared member is present (Data instances are total).
-      # @param class_name [String, nil] the tagging class name, or nil for
+      # @param class_name — the tagging class name, or nil for
       #   an instance of an anonymous `Data.define(...)` class.
       def initialize(members, class_name = nil)
         unless members.is_a?(Hash) && members.each_key.all?(Symbol)
@@ -44,12 +44,12 @@ module Rigor
         freeze
       end
 
-      # @return [Array<Symbol>] ordered member names.
+      # @return ordered member names.
       def member_names
         members.keys
       end
 
-      # @return [Rigor::Type, nil] the member's value type, or nil when the
+      # @return the member's value type, or nil when the
       #   name is not a declared member.
       def member_type(name)
         members[name]

data/lib/rigor/type/float_range.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+require_relative "acceptance_router"
+require_relative "plain_lattice"
+
+module Rigor
+  module Type
+    # A bounded float range carrier: every `Float` that the Ruby range literal it displays as would
+    # `cover?` (ADR-109 WD4). Bounds are doubles; `-Float::INFINITY` and `Float::INFINITY` are ordinary
+    # bounds, never sentinels, because Ruby orders them. The range may exclude its end (`0.0...1.0`)
+    # and never its beginning, because Ruby's literal has no exclusive begin.
+    #
+    # No bounded range contains NaN: `(a..b).cover?(Float::NAN)` is false for every `a` and `b`, so
+    # the range from `-Float::INFINITY` to `Float::INFINITY` is "every Float except NaN"
+    # (`non-nan-float`), not `Float`. The whole of `Float` (`nil..nil` in Ruby, which does cover NaN)
+    # is never a carrier; the payload builder normalises it to `Nominal[Float]`.
+    #
+    # Two spellings bound the same set when their ends are neighbouring doubles: `0.0...1.0` and
+    # `0.0..1.0.prev_float` cover the same floats. Equality, hashing and containment run on the
+    # canonical closed form (`canonical_max`); `describe` keeps the written form.
+    #
+    # Erasure to RBS is always "Float".
+    class FloatRange
+      attr_reader :min, :max
+
+      def initialize(min, max, exclude_end: false)
+        validate_bound!(min, "min")
+        validate_bound!(max, "max")
+        # `-0.0` and `0.0` are one point in the order (`-0.0 == 0.0`, `(-0.0..0.0).cover?(0.0)`); keep
+        # the one spelling so the display cannot suggest two ranges.
+        @min = min.zero? ? 0.0 : min
+        @max = max.zero? ? 0.0 : max
+        @exclude_end = exclude_end == true
+        if @min > canonical_max
+          raise ArgumentError, "FloatRange #{Range.new(@min, @max, @exclude_end).inspect} is empty"
+        end
+
+        freeze
+      end
+
+      def exclude_end?
+        @exclude_end
+      end
+
+      # The greatest double the range contains. `Float::INFINITY.prev_float` is `Float::MAX`, so an
+      # exclusive infinite end reads as "finite above".
+      def canonical_max
+        @exclude_end ? max.prev_float : max
+      end
+
+      # Every Float except NaN.
+      def universal?
+        min == -Float::INFINITY && canonical_max == Float::INFINITY
+      end
+
+      # Ruby's own predicate is the definition: the carrier covers `value` exactly when the range it
+      # displays as does.
+      def covers?(value)
+        return false unless value.is_a?(Float)
+
+        Range.new(min, max, @exclude_end).cover?(value)
+      end
+
+      # Keyed by the canonical closed bounds so a written `-Float::MAX...Float::INFINITY` reads as the
+      # set it is.
+      ALIAS_NAMES = Ractor.make_shareable({
+                                            [-Float::INFINITY, Float::INFINITY] => "non-nan-float",
+                                            [-Float::MAX, Float::MAX] => "finite-float"
+                                          })
+
+      def describe(_verbosity = :short)
+        ALIAS_NAMES[[min, canonical_max]] || generic_description
+      end
+
+      # The written form: an infinite bound is left out where Ruby's literal can (beginless, endless),
+      # spelled `Float::INFINITY` where it cannot (`...Float::INFINITY` is "finite above"), and the two
+      # extreme finite doubles read as the constants a Rubyist would write.
+      def generic_description
+        op = @exclude_end ? "..." : ".."
+        lo = min == -Float::INFINITY ? "" : float_literal(min)
+        hi = max == Float::INFINITY && !@exclude_end ? "" : float_literal(max)
+        "Float[#{lo}#{op}#{hi}]"
+      end
+
+      def erase_to_rbs
+        "Float"
+      end
+
+      include Rigor::Type::PlainLattice
+
+      include Rigor::Type::AcceptanceRouter
+
+      # Hand-written rather than `value_fields`: two carriers are the same type when they cover the
+      # same doubles, whatever end they were written with.
+      def ==(other)
+        other.is_a?(FloatRange) && min == other.min && canonical_max == other.canonical_max
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, min, canonical_max].hash
+      end
+
+      def inspect
+        "#<Rigor::Type::FloatRange #{describe(:short)}>"
+      end
+
+      private
+
+      def float_literal(value)
+        case value
+        when Float::INFINITY then "Float::INFINITY"
+        when -Float::INFINITY then "-Float::INFINITY"
+        when Float::MAX then "Float::MAX"
+        when -Float::MAX then "-Float::MAX"
+        else value.inspect
+        end
+      end
+
+      def validate_bound!(bound, label)
+        return if bound.is_a?(Float) && !bound.nan?
+
+        raise ArgumentError, "FloatRange #{label} must be a non-NaN Float, got #{bound.inspect}"
+      end
+    end
+  end
+end

data/lib/rigor/type/hash_shape.rb

@@ -34,21 +34,21 @@ module Rigor
 
       attr_reader :pairs, :required_keys, :optional_keys, :read_only_keys, :extra_keys
 
-      # @param pairs [Hash{Symbol|String => Rigor::Type}] ordered map of
+      # @param pairs — ordered map of
       #   keys to declared types. Keys MUST be Symbol or String;
       #   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
       #   carrier is a value object).
-      # @param required_keys [Array<Symbol|String>, nil] keys that MUST
+      # @param required_keys — keys that MUST
       #   be present. When omitted, every non-optional key is required.
       #   When supplied without optional_keys, every remaining known key
       #   is treated as optional.
-      # @param optional_keys [Array<Symbol|String>, nil] keys that MAY
+      # @param optional_keys — keys that MAY
       #   be absent. Optional absence is not a stored nil.
-      # @param read_only_keys [Array<Symbol|String>] entries that cannot
+      # @param read_only_keys — entries that cannot
       #   be written through this shape view.
-      # @param extra_keys [Symbol] :closed rejects keys outside pairs;
+      # @param extra_keys — :closed rejects keys outside pairs;
       #   :open permits them.
       def initialize(pairs = nil, **keywords)
         pairs, policy = split_constructor_args(pairs, keywords)

data/lib/rigor/type/integer_range.rb

@@ -8,10 +8,11 @@ require_relative "plain_lattice"
 module Rigor
   module Type
     # A bounded integer range carrier. Each bound is either an `Integer` or one of the symbolic
-    # infinities `:neg_infinity` / `:pos_infinity`. Inspired by PHPStan's `int<min, max>` family — the
-    # named aliases `positive-int` (1..), `non-negative-int` (0..), `negative-int` (..-1),
-    # `non-positive-int` (..0) all surface through this single carrier and are recovered in `describe`
-    # for human-friendly output.
+    # infinities `:neg_infinity` / `:pos_infinity`. Displayed with the Ruby range literal that
+    # `Range#cover?` would accept the same integers for (`Integer[1..10]`, `Integer[0..]`,
+    # `Integer[..-1]`; ADR-109). The named aliases `positive-int` (1..), `non-negative-int` (0..),
+    # `negative-int` (..-1), `non-positive-int` (..0) all surface through this single carrier and are
+    # recovered in `describe` for human-friendly output.
     #
     # Constraints on construction:
     # - both bounds must be either `Integer` or one of the two infinity sentinels;
@@ -76,8 +77,10 @@ module Rigor
         Float::INFINITY
       end
 
+      # The universal range reads as the class it erases to: a range with no bound carries no fact
+      # a Rubyist would spell.
       ALIAS_NAMES = Ractor.make_shareable({
-                                            [NEG_INFINITY, POS_INFINITY] => "int",
+                                            [NEG_INFINITY, POS_INFINITY] => "Integer",
                                             [1, POS_INFINITY] => "positive-int",
                                             [0, POS_INFINITY] => "non-negative-int",
                                             [NEG_INFINITY, -1] => "negative-int",
@@ -88,11 +91,13 @@ module Rigor
         ALIAS_NAMES[[min, max]] || generic_description
       end
 
+      # Always the closed form: for integers `a...b` and `a..b-1` are the same set, and the closed
+      # spelling is the one the grammar reads back without a canonicalisation step.
       def generic_description
-        return "int<#{min}, max>" if max == POS_INFINITY
-        return "int<min, #{max}>" if min == NEG_INFINITY
+        return "Integer[#{min}..]" if max == POS_INFINITY
+        return "Integer[..#{max}]" if min == NEG_INFINITY
 
-        "int<#{min}, #{max}>"
+        "Integer[#{min}..#{max}]"
       end
 
       def erase_to_rbs

data/lib/rigor/type/nominal.rb

@@ -25,13 +25,19 @@ module Rigor
     class Nominal
       attr_reader :class_name, :type_args
 
-      def initialize(class_name, type_args = [])
+      # The shared empty argument list. The raw form `Nominal["Array"]` is by far the most constructed
+      # type (~600k on the lib self-check); a fresh `[]` default plus its defensive `dup` cost two
+      # allocations per construction for an array nobody can observe.
+      EMPTY_TYPE_ARGS = [].freeze
+
+      def initialize(class_name, type_args = EMPTY_TYPE_ARGS)
         raise ArgumentError, "class_name must be a String, got #{class_name.class}" unless class_name.is_a?(String)
         raise ArgumentError, "class_name must not be empty" if class_name.empty?
         raise ArgumentError, "type_args must be an Array, got #{type_args.class}" unless type_args.is_a?(Array)
 
         @class_name = class_name.freeze
-        @type_args = type_args.dup.freeze
+        # A frozen array is already immutable, so sharing it is unobservable; only a mutable one is copied.
+        @type_args = type_args.frozen? ? type_args : type_args.dup.freeze
         freeze
       end
 

data/lib/rigor/type/refined.rb

@@ -135,8 +135,8 @@ module Rigor
       NUMERIC_LITERAL_PREFIX = /\A[+-]?\d/
       private_constant :NUMERIC_LITERAL_PREFIX
 
-      # @param value [Object] typically a `Constant#value`
-      # @return [Boolean] true when `value` is a String that is a
+      # @param value — typically a `Constant#value`
+      # @return true when `value` is a String that is a
       #   single, complete Ruby numeric literal. Total over
       #   arbitrary input — never raises (Prism reports malformed
       #   input through `errors`, it does not throw).
@@ -216,7 +216,7 @@ module Rigor
       }.freeze
       private_constant :COMPLEMENT_PAIRS
 
-      # @return [Symbol, nil] the registered complement predicate
+      # @return the registered complement predicate
       #   id, or nil when no pair is registered for this predicate.
       def complement_predicate_id
         COMPLEMENT_PAIRS[predicate_id]

data/lib/rigor/type/struct_class.rb

@@ -26,10 +26,10 @@ module Rigor
     class StructClass
       attr_reader :members, :class_name, :keyword_init
 
-      # @param members [Array<Symbol>] ordered member names.
-      # @param class_name [String, nil] the bound class name, or nil for
+      # @param members — ordered member names.
+      # @param class_name — the bound class name, or nil for
       #   the anonymous `Struct.new(...)` result.
-      # @param keyword_init [Boolean] the `keyword_init:` flag.
+      # @param keyword_init — the `keyword_init:` flag.
       def initialize(members, class_name = nil, keyword_init: false)
         unless members.is_a?(Array) && members.all?(Symbol)
           raise ArgumentError, "members must be an Array of Symbols, got #{members.inspect}"

data/lib/rigor/type/struct_instance.rb

@@ -29,9 +29,9 @@ module Rigor
     class StructInstance
       attr_reader :members, :class_name
 
-      # @param members [Hash{Symbol => Rigor::Type}] ordered member -> type
+      # @param members — ordered member -> type
       #   map. Every declared member is present (Struct instances are total).
-      # @param class_name [String, nil] the tagging class name, or nil for
+      # @param class_name — the tagging class name, or nil for
       #   an instance of an anonymous `Struct.new(...)` class.
       def initialize(members, class_name = nil)
         unless members.is_a?(Hash) && members.each_key.all?(Symbol)
@@ -46,12 +46,12 @@ module Rigor
         freeze
       end
 
-      # @return [Array<Symbol>] ordered member names.
+      # @return ordered member names.
       def member_names
         members.keys
       end
 
-      # @return [Rigor::Type, nil] the member's value type, or nil when the
+      # @return the member's value type, or nil when the
       #   name is not a declared member.
       def member_type(name)
         members[name]

data/lib/rigor/type.rb

@@ -17,6 +17,7 @@ require_relative "type/nominal"
 require_relative "type/singleton"
 require_relative "type/constant"
 require_relative "type/integer_range"
+require_relative "type/float_range"
 require_relative "type/tuple"
 require_relative "type/hash_shape"
 require_relative "type/data_class"

data/lib/rigor/type_node/generic.rb

@@ -48,7 +48,7 @@ module Rigor
       # stays additive — every earlier-shape Generic remains valid.
       def valid_arg?(arg)
         arg.is_a?(Identifier) || arg.is_a?(Generic) || arg.is_a?(IntegerLiteral) ||
-          arg.is_a?(SymbolLiteral) || arg.is_a?(StringLiteral) ||
+          arg.is_a?(SymbolLiteral) || arg.is_a?(StringLiteral) || arg.is_a?(RangeLiteral) ||
           arg.is_a?(IndexedAccess) || arg.is_a?(Union)
       end
     end

data/lib/rigor/type_node/range_literal.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rigor
+  module TypeNode
+    # Range-literal AST node: a Ruby `Range` literal in a type-arg position, spelled as Ruby spells
+    # it (`1..10`, `1...10`, `1..`, `..10`, `nil..nil`). ADR-109 makes it the bound of the numeric
+    # range refinements, `Integer[1..10]`; under any other head the resolver lifts it to a
+    # `Constant<Range>` so a plugin resolver may consume it like the other leaf literals.
+    #
+    # The value is the `Range` object itself, which already carries `begin`, `end` and
+    # `exclude_end?`; there is no second representation to keep in step. A missing endpoint is
+    # `nil`, as in Ruby.
+    class RangeLiteral < Data.define(:value)
+      def initialize(value:)
+        unless value.is_a?(Range)
+          raise ArgumentError,
+                "TypeNode::RangeLiteral value must be a Range, " \
+                "got #{value.inspect}"
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rigor/type_node/resolver_chain.rb

@@ -32,7 +32,7 @@ module Rigor
         freeze
       end
 
-      # @return [Array<Rigor::Plugin::TypeNodeResolver>] ordered
+      # @return ordered
       #   resolver instances, in plugin-registration order.
       attr_reader :resolvers