rigortype 0.1.18 → 0.2.0

data/lib/rigor/type/combinator.rb

@@ -80,6 +80,35 @@ module Rigor
         Constant.new(value)
       end
 
+      # Widens every value-pinned (`Constant`) constituent of `type` to its
+      # nominal base (`Constant[1]` -> `Nominal["Integer"]`), recursing
+      # through unions and leaving non-pinned constituents untouched.
+      # `Constant[nil]` is preserved (no nominal base of interest). Shared
+      # by the ADR-55 recursive-return fixpoint and the ADR-56 block /
+      # loop-body fixpoint (`BodyFixpoint`) to force convergence on the
+      # final permitted iteration.
+      def widen_value_pinned(type)
+        case type
+        when Constant
+          type.value.nil? ? type : nominal_of(type.value.class.name)
+        when Refined
+          # A refinement (`non-empty-string`) is a value-narrowed nominal;
+          # widen it to its base so an accumulator whose per-pass result is
+          # a bounded refinement converges on the final iteration 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 so a bounded-int accumulator
+          # converges (ADR-56).
+          nominal_of("Integer")
+        when Union
+          union(*type.members.map { |member| widen_value_pinned(member) })
+        else
+          type
+        end
+      end
+
       # `Object#method(:name)` carrier. Stores the bound
       # `(receiver, method_name)` pair so the dispatcher can
       # substitute the original dispatch at `.call` / `.()` /
@@ -376,6 +405,21 @@ module Rigor
         DataInstance.new(members, class_name)
       end
 
+      # ADR-48 Struct follow-up — the class object produced by
+      # `Struct.new(:x, :y)`. `members` is the ordered Symbol member-name
+      # list; `keyword_init` records the `keyword_init:` flag; `class_name`
+      # tags the class when known (the named-subclass form).
+      def struct_class_of(members:, class_name: nil, keyword_init: false)
+        StructClass.new(members, class_name, keyword_init: keyword_init)
+      end
+
+      # ADR-48 Struct follow-up — a `Struct.new` value instance. `members`
+      # is the ordered member-name -> value-type map; `class_name` tags the
+      # instance's class when known.
+      def struct_instance_of(members:, class_name: nil)
+        StructInstance.new(members, class_name)
+      end
+
       # Normalized union. Flattens nested Unions, deduplicates structurally
       # equal members, drops Bot, and collapses 0/1-member results.
       def union(*types)
@@ -900,9 +944,7 @@ module Rigor
         end
       end
 
-      # ADR-15 Phase 4b.x — eager-allocate the singleton
-      # `Dynamic[Top]` carrier on the main Ractor at load time.
-      # The `untyped` reader above just returns this ivar.
+      # Eager-allocated at load time; see `untyped` method comment above.
       @untyped = Dynamic.new(Top.instance)
     end
   end

data/lib/rigor/type/constant.rb

@@ -3,6 +3,7 @@
 require "date"
 require_relative "../trinary"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -100,17 +101,7 @@ module Rigor
         end
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/data_class.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -54,17 +55,7 @@ module Rigor
         "singleton(#{class_name || 'Data'})"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/data_instance.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -74,17 +75,7 @@ module Rigor
         name
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/hash_shape.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -96,17 +97,7 @@ module Rigor
         read_only_keys.include?(key)
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/integer_range.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -103,17 +104,7 @@ module Rigor
         "Integer"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/intersection.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -62,17 +63,7 @@ module Rigor
         members.first.erase_to_rbs
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/nominal.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -52,17 +53,7 @@ module Rigor
         "#{class_name}[#{rendered}]"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/plain_lattice.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+
+module Rigor
+  module Type
+    # Supplies the lattice-membership trio for the "plain" carriers — the
+    # concrete value types that are neither a lattice extreme (`Top` /
+    # `Bot` / `Dynamic`) nor a wrapper that computes membership from an
+    # inner type.
+    #
+    # Every such carrier answers `top` / `bot` / `dynamic` with the same
+    # `Trinary.no` ("this value is not that lattice point"), so the trio
+    # lived as a byte-identical copy in a dozen carriers. The extremes
+    # override the relevant member (`Top#top` / `Bot#bot` /
+    # `Dynamic#dynamic` answer `Trinary.yes`) and the delegators (`App`,
+    # `Difference`, `Refined`, `Union`) compute `dynamic` from their inner
+    # type(s); none of those include this module.
+    #
+    # Mirrors the existing {AcceptanceRouter} / `ValueSemantics` mixins —
+    # narrow trait sharing, never carrier inheritance (which the type-object
+    # contract forbids).
+    module PlainLattice
+      def top
+        Trinary.no
+      end
+
+      def bot
+        Trinary.no
+      end
+
+      def dynamic
+        Trinary.no
+      end
+    end
+  end
+end

data/lib/rigor/type/refined.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "prism"
+
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
@@ -104,18 +106,31 @@ module Rigor
       # so callers can pass any `Constant#value` without a
       # type-prefilter.
       #
-      # Plugin-contributed predicates land here once ADR-2 is
-      # in flight; today the table is closed over the v0.0.4
-      # built-in catalogue.
+      # Plugin-contributed predicates are not yet wired; today
+      # the table covers the built-in catalogue.
       #
       # Recogniser policy:
       #
-      # - `:numeric` is deliberately conservative — only decimal
-      #   integer and plain-decimal-fraction strings are
-      #   recognised, mirroring `imported-built-in-types.md`'s
-      #   "Rigor's numeric-string predicate" wording. Looser
-      #   forms (scientific, hex, rational) MAY join later
-      #   without breaking the registry contract.
+      # - `:numeric` recognises a string that is a *single Ruby
+      #   numeric literal* — exactly the syntax that, written in
+      #   Ruby source, evaluates to an `Integer` / `Float` /
+      #   `Rational` / `Complex`. The recogniser delegates to the
+      #   real Ruby parser ({Refined.ruby_numeric_literal?} via
+      #   Prism), so it tracks Ruby's grammar precisely: decimal /
+      #   `0x` hex / `0o` (or leading-zero) octal / `0b` binary /
+      #   `0d` decimal integers, underscore digit separators
+      #   (`1_000`), decimal fractions and scientific floats
+      #   (`1.5`, `1E-5`), and the `r` rational / `i` imaginary
+      #   suffixes (`1r`, `2i`, `0xffr`). A single leading sign is
+      #   folded into the literal (`-1`, `+1.5`), but a doubled
+      #   sign (`--1`, `++1`) parses as a unary-operator chain — a
+      #   `CallNode`, not a literal — and is rejected, as are
+      #   multi-dot junk (`1.2.3`), partial literals (`0x`, `1_`),
+      #   whitespace-padded strings, and — crucially — non-ASCII
+      #   "digits" (full-width `１`, superscript `²`, other Unicode
+      #   number characters): Ruby's lexer only accepts `[0-9]` in
+      #   a numeric literal, so those are `CallNode`s too. The
+      #   stricter base-N predicates below remain proper subsets.
       # - `:decimal_int` is "what `Integer(s, 10)` would parse
       #   without remainder" — one or more decimal digits,
       #   optional leading sign, no whitespace, no fractional
@@ -127,20 +142,64 @@ module Rigor
       #   not octal-int-string. This matches the typical user
       #   intent — a refinement marks a string that "looks like
       #   octal", not "happens to be base-8 valid".
-      NUMERIC_STRING_PATTERN = /\A-?\d+(?:\.\d+)?\z/
       DECIMAL_INT_STRING_PATTERN = /\A-?\d+\z/
       OCTAL_INT_STRING_PATTERN = /\A-?(?:0[oO][0-7]+|0[0-7]+)\z/
       HEX_INT_STRING_PATTERN = /\A-?0[xX][0-9a-fA-F]+\z/
-      private_constant :NUMERIC_STRING_PATTERN, :DECIMAL_INT_STRING_PATTERN,
+      private_constant :DECIMAL_INT_STRING_PATTERN,
                        :OCTAL_INT_STRING_PATTERN, :HEX_INT_STRING_PATTERN
 
+      # Prism node classes that represent a numeric literal. A
+      # string is a numeric-string exactly when the parser reduces
+      # the whole input to a single one of these (the leading sign
+      # is already folded into the literal by the parser).
+      NUMERIC_LITERAL_NODES = [
+        Prism::IntegerNode,
+        Prism::FloatNode,
+        Prism::RationalNode,
+        Prism::ImaginaryNode
+      ].freeze
+      private_constant :NUMERIC_LITERAL_NODES
+
+      # Cheap pre-filter applied before invoking the parser: every
+      # Ruby numeric literal starts with an ASCII digit, optionally
+      # preceded by exactly one sign. Strings that fail this never
+      # reach Prism (the common non-numeric case stays allocation-
+      # and parse-free).
+      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
+      #   single, complete Ruby numeric literal. Total over
+      #   arbitrary input — never raises (Prism reports malformed
+      #   input through `errors`, it does not throw).
+      def self.ruby_numeric_literal?(value)
+        return false unless value.is_a?(String)
+        return false if value.empty?
+        # A numeric literal carries no whitespace; reject any
+        # leading / trailing / interior space so the *whole* string
+        # must be the literal (Prism would otherwise accept a
+        # trailing-space `"1 "`).
+        return false if value.match?(/\s/)
+        return false unless value.match?(NUMERIC_LITERAL_PREFIX)
+
+        result = Prism.parse(value)
+        return false unless result.errors.empty?
+
+        body = result.value.statements&.body
+        return false unless body && body.size == 1
+
+        node = body.first
+        NUMERIC_LITERAL_NODES.any? { |klass| node.is_a?(klass) }
+      end
+
       PREDICATES = {
         lowercase: ->(v) { v.is_a?(String) && v == v.downcase },
         not_lowercase: ->(v) { v.is_a?(String) && v != v.downcase },
         uppercase: ->(v) { v.is_a?(String) && v == v.upcase },
         not_uppercase: ->(v) { v.is_a?(String) && v != v.upcase },
-        numeric: ->(v) { v.is_a?(String) && NUMERIC_STRING_PATTERN.match?(v) },
-        not_numeric: ->(v) { v.is_a?(String) && !NUMERIC_STRING_PATTERN.match?(v) },
+        numeric: ->(v) { ruby_numeric_literal?(v) },
+        not_numeric: ->(v) { v.is_a?(String) && !ruby_numeric_literal?(v) },
         decimal_int: ->(v) { v.is_a?(String) && DECIMAL_INT_STRING_PATTERN.match?(v) },
         octal_int: ->(v) { v.is_a?(String) && OCTAL_INT_STRING_PATTERN.match?(v) },
         hex_int: ->(v) { v.is_a?(String) && HEX_INT_STRING_PATTERN.match?(v) },

data/lib/rigor/type/singleton.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -34,17 +35,7 @@ module Rigor
         "singleton(#{class_name})"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/struct_class.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+require_relative "../value_semantics"
+require_relative "acceptance_router"
+require_relative "plain_lattice"
+
+module Rigor
+  module Type
+    # The class object produced by `Struct.new(:x, :y)` (ADR-48 Struct
+    # follow-up). The mutable sibling of {DataClass}: it models the *class*
+    # (the value bound to `Point` in `Point = Struct.new(:x, :y)`, or the
+    # anonymous superclass in `class Point < Struct.new(:x, :y)`), carrying
+    # the ordered member-name list so `Point.new(...)` can materialise a
+    # {StructInstance}.
+    #
+    # `keyword_init` records the `Struct.new(..., keyword_init: true)` flag
+    # so `.new` only materialises a precise instance for the matching call
+    # form — a positional `.new(1, 2)` on a `keyword_init: true` struct, or
+    # a keyword `.new(x: 1)` on a positional struct, is a different runtime
+    # shape and must degrade rather than fold a wrong member map.
+    #
+    # `class_name` carries the binding name when known (the named-subclass
+    # form) and is `nil` for the anonymous result of a bare `Struct.new(...)`
+    # before it is assigned to a constant.
+    #
+    # Equality and hashing are structural over the member list, the class
+    # name, and the keyword-init flag.
+    #
+    # See docs/adr/48-data-struct-value-folding.md § "Struct follow-up".
+    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
+      #   the anonymous `Struct.new(...)` result.
+      # @param keyword_init [Boolean] 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}"
+        end
+        unless class_name.nil? || (class_name.is_a?(String) && !class_name.empty?)
+          raise ArgumentError, "class_name must be a non-empty String or nil, got #{class_name.inspect}"
+        end
+
+        @members = members.dup.freeze
+        @class_name = class_name&.freeze
+        @keyword_init = keyword_init ? true : false
+        freeze
+      end
+
+      def describe(_verbosity = :short)
+        return "singleton(#{class_name})" if class_name
+
+        "Struct.new(#{members.map(&:inspect).join(', ')})"
+      end
+
+      def erase_to_rbs
+        "singleton(#{class_name || 'Struct'})"
+      end
+
+      include Rigor::Type::PlainLattice
+
+      include Rigor::Type::AcceptanceRouter
+
+      include Rigor::ValueSemantics
+
+      value_fields :members, :class_name, :keyword_init
+
+      def inspect
+        "#<Rigor::Type::StructClass #{describe(:short)}>"
+      end
+    end
+  end
+end

data/lib/rigor/type/struct_instance.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+require_relative "../value_semantics"
+require_relative "acceptance_router"
+require_relative "plain_lattice"
+
+module Rigor
+  module Type
+    # A `Struct.new` value instance (ADR-48 Struct follow-up) —
+    # `Point.new(1, 2)`. The mutable sibling of {DataInstance}: a closed,
+    # total, class-tagged member map (member name -> value type),
+    # HashShape-shaped but nominal.
+    #
+    # Unlike {DataInstance}, a `Struct` instance is **mutable** — `s.x = v`,
+    # `s[:x] = v`, and escape can invalidate the member map. The folding
+    # tier therefore only projects member reads off a **fresh** instance
+    # (the transient receiver of a `.new(...).x` / `.with(...).x` chain,
+    # which provably cannot have been mutated between materialisation and
+    # the read); a read off a *stored* binding degrades to `Dynamic[top]`
+    # rather than fold a possibly-stale member value. Promoting the
+    # fold to mutation-free bound locals is the deferred slice 3 (see ADR).
+    #
+    # That mutability-gating lives in the dispatch tier (`StructFolding`),
+    # not the carrier: the carrier itself just records the member map. Like
+    # {DataInstance}, non-folded methods project to the `Struct` nominal (or
+    # the tagged class) through {RbsDispatch}'s `receiver_descriptor`, so
+    # non-member calls resolve without mis-firing undefined-method.
+    #
+    # Equality and hashing are structural over the (member -> type) map and
+    # the class name.
+    #
+    # See docs/adr/48-data-struct-value-folding.md § "Struct follow-up".
+    class StructInstance
+      attr_reader :members, :class_name
+
+      # @param members [Hash{Symbol => Rigor::Type}] 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
+      #   an instance of an anonymous `Struct.new(...)` class.
+      def initialize(members, class_name = nil)
+        unless members.is_a?(Hash) && members.each_key.all?(Symbol)
+          raise ArgumentError, "members must be a Hash with Symbol keys, got #{members.inspect}"
+        end
+        unless class_name.nil? || (class_name.is_a?(String) && !class_name.empty?)
+          raise ArgumentError, "class_name must be a non-empty String or nil, got #{class_name.inspect}"
+        end
+
+        @members = members.dup.freeze
+        @class_name = class_name&.freeze
+        freeze
+      end
+
+      # @return [Array<Symbol>] ordered member names.
+      def member_names
+        members.keys
+      end
+
+      # @return [Rigor::Type, nil] the member's value type, or nil when the
+      #   name is not a declared member.
+      def member_type(name)
+        members[name]
+      end
+
+      def describe(verbosity = :short)
+        rendered = members.map { |name, type| "#{name}: #{type.describe(verbosity)}" }
+        "#{class_name || 'Struct'}(#{rendered.join(', ')})"
+      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.
+      def erase_to_rbs
+        name = class_name
+        return "Struct" if name.nil?
+
+        name
+      end
+
+      include Rigor::Type::PlainLattice
+
+      include Rigor::Type::AcceptanceRouter
+
+      include Rigor::ValueSemantics
+
+      value_fields :members, :class_name
+
+      def inspect
+        "#<Rigor::Type::StructInstance #{describe(:short)}>"
+      end
+    end
+  end
+end

data/lib/rigor/type/tuple.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -17,10 +18,9 @@ module Rigor
     #
     # Slice 5 phase 1 introduces the carrier and surfaces it from the
     # `ArrayNode` literal handler when every element is a non-splat
-    # value. Tuple-aware refinements for `tuple[0]`, `tuple.first`, and
-    # destructuring assignment are deferred to Slice 5 phase 2; they
-    # will run as a higher-priority dispatch tier above
-    # {Rigor::Inference::MethodDispatcher::RbsDispatch}.
+    # value. Tuple-aware refinements (`tuple[0]`, `tuple.first`,
+    # destructuring) are implemented in `ShapeDispatch`, which runs
+    # above {Rigor::Inference::MethodDispatcher::RbsDispatch}.
     #
     # Equality and hashing are structural across an ordered, frozen
     # element list. The empty Tuple `Tuple[]` is permitted; the array
@@ -53,17 +53,7 @@ module Rigor
         "[#{elements.map(&:erase_to_rbs).join(', ')}]"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type.rb

@@ -21,6 +21,8 @@ require_relative "type/tuple"
 require_relative "type/hash_shape"
 require_relative "type/data_class"
 require_relative "type/data_instance"
+require_relative "type/struct_class"
+require_relative "type/struct_instance"
 require_relative "type/union"
 require_relative "type/difference"
 require_relative "type/refined"

data/lib/rigor/version.rb

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

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

@@ -26,7 +26,7 @@ module Rigor
       #   `stream_for` call) so the analyzer knows it can't
       #   be sure of every stream name.
       #
-      # Limitations (intentional for v0.1.0):
+      # Intentional limitations:
       #
       # - Direct-superclass match only.
       # - Public-vs-private is not tracked; the framework