rigortype 0.3.8 → 0.4.0

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,111 @@ module Rigor
 
           return [top] if flattened.any?(Top)
 
-          unique_members(flattened)
+          absorb_contained_members(unique_members(flattened))
+        end
+
+        # Drops every member another member already contains, so the join after a guard names one set
+        # instead of several readings of it. The normative relation is
+        # docs/type-specification/normalization.md § "Member absorption"; {absorbed_by?} is that list.
+        #
+        # Only a `FloatRange`, `Tuple` or `HashShape` member can be dropped, so the O(n²) scan is
+        # skipped for every union that carries none of them — this runs on the hot path of every join.
+        #
+        # The `!absorbed_by?(other, member)` re-check costs one predicate call per pair that absorbed
+        # at all, and it is what makes "both arms dropped" unrepresentable should a future clause make
+        # the relation symmetric on a pair of distinct members.
+        def absorb_contained_members(members)
+          return members unless members.any? { |m| absorbable_member?(m) }
+
+          members.reject do |member|
+            absorbable_member?(member) &&
+              members.any? do |other|
+                !other.equal?(member) && absorbed_by?(member, other) && !absorbed_by?(other, member)
+              end
+          end
+        end
+
+        def absorbable_member?(type)
+          type.is_a?(FloatRange) || type.is_a?(Tuple) || type.is_a?(HashShape)
+        end
+
+        # `narrower`'s inhabitants are a subset of `wider`'s under a rule the union already applies to
+        # a direct member. The structural clauses only lift that same relation element-wise over a
+        # fixed spine; none of them introduces an absorption the flat union does not already perform,
+        # which is why a value-pinned element never collapses (normalization.md keeps `1 | Integer`,
+        # so `[1, String] | [Integer, String]` keeps both arms) and an `IntegerRange` or `Refined`
+        # element never does either.
+        def absorbed_by?(narrower, wider)
+          return true if wider.is_a?(Top) || narrower.is_a?(Bot)
+          return true if listed_in_union?(narrower, wider)
+
+          case narrower
+          when FloatRange then float_range_absorbed_by?(narrower, wider)
+          when Tuple then wider.is_a?(Tuple) && tuple_absorbed_by?(narrower, wider)
+          when HashShape then wider.is_a?(HashShape) && hash_shape_absorbed_by?(narrower, wider)
+          when Union then union_absorbed_by?(narrower, wider)
+          else false
+          end
+        end
+
+        # Flatten-and-dedupe read one level down: the member is already one of the arms `wider` lists.
+        def listed_in_union?(narrower, wider)
+          wider.is_a?(Union) && wider.members.any? { |member| element_absorbed_or_equal?(narrower, member) }
+        end
+
+        def union_absorbed_by?(narrower, wider)
+          narrower.members.all? { |member| element_absorbed_or_equal?(member, wider) }
+        end
+
+        def element_absorbed_or_equal?(narrower, wider)
+          narrower.equal?(wider) || narrower == wider || absorbed_by?(narrower, wider)
+        end
+
+        # ADR-109 WD5 — a `FloatRange` is absorbed by a bare `Nominal[Float]` or by a `FloatRange` 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 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
+
+        # Differing arity is never absorbed: `[A]` and `[A, B]` have disjoint inhabitants, so neither
+        # arm is a reading of the other.
+        def tuple_absorbed_by?(narrower, wider)
+          return false unless narrower.elements.size == wider.elements.size
+
+          narrower.elements.each_with_index.all? do |element, index|
+            element_absorbed_or_equal?(element, wider.elements[index])
+          end
+        end
+
+        def hash_shape_absorbed_by?(narrower, wider)
+          return false unless hash_shape_spine_equal?(narrower, wider)
+
+          narrower.pairs.all? { |key, value| element_absorbed_or_equal?(value, wider.pairs[key]) }
+        end
+
+        # The spine is everything but the value types: the key set and the openness / optionality /
+        # read-only policy. Two shapes that disagree on any of it describe differently-shaped hashes,
+        # and an element-wise reading of their values would not be a containment.
+        def hash_shape_spine_equal?(narrower, wider)
+          narrower.pairs.size == wider.pairs.size &&
+            narrower.extra_keys == wider.extra_keys &&
+            narrower.required_keys == wider.required_keys &&
+            narrower.optional_keys == wider.optional_keys &&
+            narrower.read_only_keys == wider.read_only_keys &&
+            narrower.pairs.each_key.all? { |key| wider.pairs.key?(key) }
         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 +998,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/difference.rb

@@ -70,6 +70,7 @@ module Rigor
         "Array" => ->(removed) { removed.is_a?(Tuple) && removed.elements.empty? },
         "Hash" => ->(removed) { removed.is_a?(HashShape) && removed.pairs.empty? }
       }.freeze
+      Ractor.make_shareable(EMPTY_WITNESS_PREDICATES)
       private_constant :EMPTY_WITNESS_PREDICATES
 
       def top

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)
@@ -60,7 +60,7 @@ module Rigor
       end
 
       def describe(verbosity = :short)
-        return "{}" if pairs.empty?
+        return "{}" if pairs.empty? && closed?
 
         rendered = pairs.map { |k, v| render_entry(k, v, verbosity) }
         rendered << "..." if open?

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).
@@ -176,6 +176,7 @@ module Rigor
         # recovered by inspecting an arbitrary string.
         literal_string: ->(v) { v.is_a?(String) }
       }.freeze
+      Ractor.make_shareable(PREDICATES)
 
       # Maps `[base_class_name, predicate_id]` pairs to their kebab-case canonical name. Registered
       # shapes print through `describe`; unregistered combinations fall back to the operator form.
@@ -216,7 +217,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
 

data/lib/rigor/type_node.rb

@@ -11,6 +11,7 @@ end
 
 require_relative "type_node/identifier"
 require_relative "type_node/integer_literal"
+require_relative "type_node/range_literal"
 require_relative "type_node/symbol_literal"
 require_relative "type_node/string_literal"
 require_relative "type_node/generic"

data/lib/rigor/version.rb

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

data/lib/rigor.rb

@@ -10,6 +10,7 @@ require_relative "rigor/environment"
 require_relative "rigor/rbs_extended"
 require_relative "rigor/testing"
 require_relative "rigor/inference/budget_trace"
+require_relative "rigor/inference/external_ancestor_resolution"
 require_relative "rigor/inference/dynamic_origin"
 require_relative "rigor/inference/fallback"
 require_relative "rigor/inference/fallback_tracer"

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

@@ -34,10 +34,6 @@ module Rigor
         # The broadcast violations for a single call node, or `[]` when the node is not a
         # `broadcast_to` / `ActionCable.server.broadcast` call this plugin recognises. ADR-37: the
         # engine owns the walk.
-        #
-        # @param call_node [Prism::Node]
-        # @param channel_index [ChannelIndex]
-        # @return [Array<Violation>]
         def violations_for(call_node:, channel_index:)
           return [] unless call_node.is_a?(Prism::CallNode)