rigortype 0.0.3 → 0.0.5

data/lib/rigor/type/combinator.rb

@@ -11,6 +11,8 @@ require_relative "tuple"
 require_relative "hash_shape"
 require_relative "union"
 require_relative "difference"
+require_relative "refined"
+require_relative "intersection"
 
 module Rigor
   module Type
@@ -133,6 +135,65 @@ module Rigor
         )
       end
 
+      # Predicate-subset refinement carrier (ADR-3 OQ3 Option C,
+      # second half). Use `lowercase_string` /
+      # `uppercase_string` / `numeric_string` for the imported
+      # built-in shapes; raw `refined(base, predicate_id)` for
+      # ad-hoc refinements introduced by an `RBS::Extended`
+      # annotation or a plugin-contributed predicate.
+      def refined(base, predicate_id)
+        Refined.new(base, predicate_id)
+      end
+
+      def lowercase_string
+        Refined.new(nominal_of("String"), :lowercase)
+      end
+
+      def uppercase_string
+        Refined.new(nominal_of("String"), :uppercase)
+      end
+
+      def numeric_string
+        Refined.new(nominal_of("String"), :numeric)
+      end
+
+      def decimal_int_string
+        Refined.new(nominal_of("String"), :decimal_int)
+      end
+
+      def octal_int_string
+        Refined.new(nominal_of("String"), :octal_int)
+      end
+
+      def hex_int_string
+        Refined.new(nominal_of("String"), :hex_int)
+      end
+
+      # Normalised intersection. Flattens nested Intersections,
+      # drops `Top` members, collapses to `Bot` if any member is
+      # `Bot`, deduplicates structurally-equal members, sorts the
+      # survivors by `describe(:short)`, and collapses 0-/1-member
+      # results so a degenerate intersection never reaches the
+      # carrier. See ADR-3 OQ3 for the rationale; the lattice
+      # algebra is in
+      # [`value-lattice.md`](docs/type-specification/value-lattice.md).
+      def intersection(*members)
+        collapse_intersection(normalised_intersection_members(members))
+      end
+
+      # `non-empty-lowercase-string` = non-empty-string ∩
+      # lowercase-string. Composes the point-removal half
+      # (`Difference[String, ""]`) with the predicate-subset half
+      # (`Refined[String, :lowercase]`). Both members erase to
+      # `String` so the carrier's RBS erasure is unambiguous.
+      def non_empty_lowercase_string
+        intersection(non_empty_string, lowercase_string)
+      end
+
+      def non_empty_uppercase_string
+        intersection(non_empty_string, uppercase_string)
+      end
+
       # Constructs a heterogeneous, fixed-arity Tuple from positional
       # element types. `tuple_of()` produces the empty tuple `Tuple[]`,
       # which is structurally distinct from the raw `Nominal[Array]`.
@@ -185,6 +246,35 @@ module Rigor
           end
         end
 
+        # Symmetric counterparts to the Union normalisers. The
+        # absorbing element is `Bot` (anything intersected with
+        # nothing is nothing) and the identity element is `Top`
+        # (intersecting with the universal type is a no-op).
+        def normalised_intersection_members(types)
+          flattened = []
+          types.each { |t| flatten_intersection_into(flattened, t) }
+          return [bot] if flattened.any?(Bot)
+
+          flattened.reject! { |t| t.is_a?(Top) }
+          unique_members(flattened)
+        end
+
+        def collapse_intersection(types)
+          case types.size
+          when 0 then top
+          when 1 then types.first
+          else Intersection.new(sort_members(types))
+          end
+        end
+
+        def flatten_intersection_into(acc, type)
+          if type.is_a?(Intersection)
+            type.members.each { |m| flatten_intersection_into(acc, m) }
+          else
+            acc << type
+          end
+        end
+
         def resolve_class_name(class_name_or_object)
           name =
             case class_name_or_object

data/lib/rigor/type/integer_range.rb

@@ -65,11 +65,13 @@ module Rigor
       # `:neg_infinity`). Use this in arithmetic comparisons; never compare
       # `:neg_infinity` directly with an `Integer`.
       def lower
-        min == NEG_INFINITY ? -Float::INFINITY : min
+        m = min
+        m.is_a?(Symbol) ? -Float::INFINITY : m
       end
 
       def upper
-        max == POS_INFINITY ? Float::INFINITY : max
+        m = max
+        m.is_a?(Symbol) ? Float::INFINITY : m
       end
 
       ALIAS_NAMES = {

data/lib/rigor/type/intersection.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+
+module Rigor
+  module Type
+    # `Intersection[M1, M2, …]` — value set is the meet of every
+    # member's value set. The carrier composes refinements that
+    # share a base, in particular the catalogued
+    # `non-empty-lowercase-string` (= `Difference[String, ""] &
+    # Refined[String, :lowercase]`) and
+    # `non-empty-uppercase-string` shapes from
+    # [`imported-built-in-types.md`](docs/type-specification/imported-built-in-types.md).
+    # See [ADR-3](docs/adr/3-type-representation.md) for the
+    # OQ3 working decision and the rationale for keeping
+    # Intersection a thin wrapper rather than per-shape carriers.
+    #
+    # Construction MUST go through `Type::Combinator.intersection`
+    # (or the per-name factories
+    # `Combinator.non_empty_lowercase_string` /
+    # `Combinator.non_empty_uppercase_string`). The factory:
+    #
+    # - flattens nested intersections,
+    # - drops `Top` members (Top is the identity of intersection),
+    # - collapses to `Bot` if any member is `Bot` (Bot is absorbing),
+    # - deduplicates structurally-equal members,
+    # - sorts the surviving members by `describe(:short)` so two
+    #   structurally-equal intersections built in different orders
+    #   compare equal,
+    # - returns `Top` for the empty intersection,
+    # - returns the lone member for a 1-element intersection (so
+    #   the carrier is never inhabited by a degenerate single-member
+    #   shape).
+    #
+    # Direct `.new` callers MUST pass an already-normalised member
+    # list and are expected to be tests or the combinator itself.
+    class Intersection
+      attr_reader :members
+
+      def initialize(members)
+        @members = members.dup.freeze
+        freeze
+      end
+
+      def describe(verbosity = :short)
+        named = canonical_name
+        return named if named
+
+        members.map { |m| m.describe(verbosity) }.join(" & ")
+      end
+
+      # An intersection of refinements over the same base type
+      # erases to that base. We use the first member's erasure
+      # because the v0.0.4 catalogue (`non-empty-lowercase-string`
+      # etc.) is restricted to same-base composition; richer
+      # cross-base intersections will need a stricter erasure
+      # rule (likely "lowest common ancestor" via the inference
+      # engine's class hierarchy).
+      def erase_to_rbs
+        members.first.erase_to_rbs
+      end
+
+      def top
+        Trinary.no
+      end
+
+      def bot
+        Trinary.no
+      end
+
+      def dynamic
+        Trinary.no
+      end
+
+      def accepts(other, mode: :gradual)
+        Inference::Acceptance.accepts(self, other, mode: mode)
+      end
+
+      def ==(other)
+        other.is_a?(Intersection) && members == other.members
+      end
+      alias eql? ==
+
+      def hash
+        [Intersection, members].hash
+      end
+
+      def inspect
+        "#<Rigor::Type::Intersection #{describe(:short)}>"
+      end
+
+      private
+
+      # Maps a structurally-recognised composite shape to its
+      # kebab-case canonical name. The recognised set is kept in
+      # sync with the imported-built-in catalogue
+      # ([`imported-built-in-types.md`](docs/type-specification/imported-built-in-types.md)).
+      #
+      # Detection is order-independent — `Combinator.intersection`
+      # sorts the canonical member list, but reading the registry
+      # the other way around (a user-authored Intersection built
+      # in any order) MUST still print in its canonical spelling.
+      def canonical_name
+        return nil unless members.size == 2
+
+        bases = members.map { |m| canonical_role(m) }.compact
+        return nil unless bases.size == 2
+
+        roles = bases.sort
+        case roles
+        when %w[lowercase non_empty_string] then "non-empty-lowercase-string"
+        when %w[non_empty_string uppercase] then "non-empty-uppercase-string"
+        end
+      end
+
+      # Returns a stable role tag for the recognised composite
+      # members so `canonical_name` can pattern-match on a sorted
+      # role pair regardless of construction order. Returns nil
+      # when the member is not part of any catalogued composite —
+      # any nil contribution disqualifies the canonical-name path
+      # and the operator-form fallback kicks in.
+      def canonical_role(member)
+        case member
+        when Difference
+          "non_empty_string" if member == Type::Combinator.non_empty_string
+        when Refined
+          case member
+          when Type::Combinator.lowercase_string then "lowercase"
+          when Type::Combinator.uppercase_string then "uppercase"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/type/refined.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+
+module Rigor
+  module Type
+    # `Refined[base, predicate_id]` — predicate-subset half of
+    # the OQ3 refinement-carrier strategy
+    # ([ADR-3](docs/adr/3-type-representation.md), Working
+    # Decision Option C). Sibling of `Type::Difference`, which
+    # carries the point-removal half.
+    #
+    #   lowercase-string = Refined[Nominal[String], :lowercase]
+    #   uppercase-string = Refined[Nominal[String], :uppercase]
+    #   numeric-string   = Refined[Nominal[String], :numeric]
+    #
+    # The carrier wraps a base type and a `predicate_id` Symbol
+    # drawn from {PREDICATES}. The recogniser is invoked at
+    # constant-fold and acceptance time over a `Constant<base>`
+    # value; for non-Constant receivers the carrier is a marker
+    # the catalog tier consults to project `String#downcase` /
+    # `String#upcase` (etc.) into the matching refinement.
+    #
+    # Display routes through {CANONICAL_NAMES}: registered
+    # `(base_class_name, predicate_id)` pairs print in their
+    # kebab-case spelling (`lowercase-string`); unregistered
+    # combinations fall back to the `base & predicate?` operator
+    # form per
+    # [`type-operators.md`](docs/type-specification/type-operators.md).
+    #
+    # Construction MUST go through `Type::Combinator.refined` /
+    # the per-name factories (`Combinator.lowercase_string`,
+    # `Combinator.uppercase_string`, `Combinator.numeric_string`).
+    # Direct `.new` is an internal escape hatch for tests and
+    # combinator's own implementation.
+    class Refined
+      attr_reader :base, :predicate_id
+
+      def initialize(base, predicate_id)
+        raise ArgumentError, "predicate_id must be a Symbol" unless predicate_id.is_a?(Symbol)
+
+        @base = base
+        @predicate_id = predicate_id
+        freeze
+      end
+
+      def describe(verbosity = :short)
+        named = canonical_name
+        return named if named
+
+        "#{base.describe(verbosity)} & #{predicate_id}?"
+      end
+
+      # Erases to the base nominal: every refinement MUST erase
+      # to its base per [`rbs-erasure.md`](docs/type-specification/rbs-erasure.md).
+      def erase_to_rbs
+        base.erase_to_rbs
+      end
+
+      def top
+        Trinary.no
+      end
+
+      def bot
+        Trinary.no
+      end
+
+      def dynamic
+        base.respond_to?(:dynamic) ? base.dynamic : Trinary.no
+      end
+
+      def accepts(other, mode: :gradual)
+        Inference::Acceptance.accepts(self, other, mode: mode)
+      end
+
+      def ==(other)
+        other.is_a?(Refined) && base == other.base && predicate_id == other.predicate_id
+      end
+      alias eql? ==
+
+      def hash
+        [Refined, base, predicate_id].hash
+      end
+
+      def inspect
+        "#<Rigor::Type::Refined #{describe(:short)}>"
+      end
+
+      # Recognises a Ruby value against this carrier's
+      # predicate. The trinary return is intentional: `true` /
+      # `false` when the predicate registry decides, `nil`
+      # when the predicate is unknown to the registry, so
+      # callers (today {Inference::Acceptance}) can fall
+      # through to gradual-mode `:maybe`.
+      # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
+      def matches?(value)
+        recogniser = PREDICATES[predicate_id]
+        return nil if recogniser.nil?
+
+        !!recogniser.call(value)
+      end
+      # rubocop:enable Style/ReturnNilInPredicateMethodDefinition
+
+      # `predicate_id => recogniser` table. The recogniser is
+      # called with a Ruby value (typically the inner `value`
+      # of a `Constant`) and returns truthy when the value
+      # satisfies the predicate. The recogniser MUST be total
+      # (return false rather than raise) over arbitrary input,
+      # 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.
+      #
+      # 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.
+      # - `:decimal_int` is "what `Integer(s, 10)` would parse
+      #   without remainder" — one or more decimal digits,
+      #   optional leading sign, no whitespace, no fractional
+      #   tail.
+      # - `:octal_int` and `:hex_int` REQUIRE their conventional
+      #   prefix (`0o` / `0O` / leading `0` for octal; `0x` /
+      #   `0X` for hex) so the predicate is disjoint from
+      #   `:decimal_int`. A bare `"755"` is decimal-int-string,
+      #   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,
+                       :OCTAL_INT_STRING_PATTERN, :HEX_INT_STRING_PATTERN
+
+      PREDICATES = {
+        lowercase: ->(v) { v.is_a?(String) && v == v.downcase },
+        uppercase: ->(v) { v.is_a?(String) && v == v.upcase },
+        numeric: ->(v) { v.is_a?(String) && NUMERIC_STRING_PATTERN.match?(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) }
+      }.freeze
+
+      # 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.
+      CANONICAL_NAMES = {
+        ["String", :lowercase] => "lowercase-string",
+        ["String", :uppercase] => "uppercase-string",
+        ["String", :numeric] => "numeric-string",
+        ["String", :decimal_int] => "decimal-int-string",
+        ["String", :octal_int] => "octal-int-string",
+        ["String", :hex_int] => "hex-int-string"
+      }.freeze
+      private_constant :CANONICAL_NAMES
+
+      private
+
+      def canonical_name
+        return nil unless base.is_a?(Nominal)
+
+        CANONICAL_NAMES[[base.class_name, predicate_id]]
+      end
+    end
+  end
+end

data/lib/rigor/type.rb

@@ -21,5 +21,7 @@ require_relative "type/tuple"
 require_relative "type/hash_shape"
 require_relative "type/union"
 require_relative "type/difference"
+require_relative "type/refined"
+require_relative "type/intersection"
 require_relative "type/accepts_result"
 require_relative "type/combinator"

data/lib/rigor/version.rb

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

data/sig/rigor/environment.rbs

@@ -38,15 +38,13 @@ module Rigor
 
       def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath]) -> void
       def class_known?: (String | Symbol name) -> bool
-      def instance_definition: (String | Symbol class_name) -> untyped
-      def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped
-      def singleton_definition: (String | Symbol class_name) -> untyped
-      def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped
+      def instance_definition: (String | Symbol class_name) -> untyped?
+      def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
+      def singleton_definition: (String | Symbol class_name) -> untyped?
+      def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
       def class_type_param_names: (String | Symbol class_name) -> Array[Symbol]
       def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
       def constant_type: (String name) -> Type::t?
-      def instance_definition: (String | Symbol class_name) -> untyped?
-      def singleton_definition: (String | Symbol class_name) -> untyped?
     end
 
     class RbsHierarchy

data/sig/rigor/inference.rbs

@@ -85,6 +85,7 @@ module Rigor
       def self?.narrow_not_equal: (Type::t type, untyped literal) -> Type::t
       def self?.narrow_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
       def self?.narrow_not_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
+      def self?.narrow_not_refinement: (Type::t current_type, Type::t refinement_type) -> Type::t
       def self?.predicate_scopes: (untyped node, Scope scope) -> [Scope, Scope]
       def self?.case_when_scopes: (untyped subject, Array[untyped] conditions, Scope scope) -> [Scope, Scope]
       def self?.analyse: (untyped node, Scope scope) -> untyped
@@ -131,7 +132,7 @@ module Rigor
     module ScopeIndexer
       def self?.index: (untyped root, default_scope: Scope) -> Hash[untyped, Scope]
       def self?.build_declaration_overrides: (untyped root) -> Hash[untyped, Type::t]
-      def self?.record_declarations: (untyped node, Array[String] qualified_prefix, Hash[untyped, Type::t] table) -> void
+      def self?.record_declarations: (untyped node, Array[String] qualified_prefix, Hash[untyped, Type::t] identity_table, Hash[String, Type::t] discovered) -> void
       def self?.qualified_name_for: (untyped constant_path_node) -> String?
       def self?.render_constant_path: (untyped node) -> String
       def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void

data/sig/rigor/rbs_extended.rbs

@@ -42,5 +42,16 @@ module Rigor
 
     def self?.read_return_type_override: (untyped method_def) -> Type::t?
     def self?.parse_return_type_override: (String string) -> Type::t?
+
+    class ParamOverride
+      attr_reader param_name: Symbol
+      attr_reader type: Type::t
+
+      def self.new: (param_name: Symbol, type: Type::t) -> ParamOverride
+    end
+
+    def self?.read_param_type_overrides: (untyped method_def) -> Array[ParamOverride]
+    def self?.param_type_override_map: (untyped method_def) -> Hash[Symbol, Type::t]
+    def self?.parse_param_annotation: (String string) -> ParamOverride?
   end
 end