rigortype 0.0.2 → 0.0.4

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

@@ -16,8 +16,12 @@ require_relative "type/dynamic"
 require_relative "type/nominal"
 require_relative "type/singleton"
 require_relative "type/constant"
+require_relative "type/integer_range"
 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.2"
+  VERSION = "0.0.4"
 end

data/sig/rigor/rbs_extended.rbs

@@ -39,5 +39,19 @@ module Rigor
 
     def self?.read_assert_effects: (untyped method_def) -> Array[AssertEffect]
     def self?.parse_assert_annotation: (String string) -> AssertEffect?
+
+    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

data/sig/rigor/scope.rbs

@@ -38,6 +38,7 @@ module Rigor
     def discovered_method?: (String | Symbol class_name, String | Symbol method_name, Symbol kind) -> bool
     def with_discovered_def_nodes: (Hash[String, Hash[Symbol, untyped]] table) -> Scope
     def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
+    def top_level_def_for: (String | Symbol method_name) -> untyped?
     def with_fact: (Analysis::FactStore::Fact fact) -> Scope
     def with_self_type: (Type::t? type) -> Scope
     def with_declared_types: (Hash[untyped, Type::t] table) -> Scope

data/sig/rigor/type.rbs

@@ -1,6 +1,6 @@
 module Rigor
   module Type
-    type t = Top | Bot | Dynamic | Constant | Nominal | Singleton | Union | Tuple | HashShape
+    type t = Top | Bot | Dynamic | Constant | IntegerRange | Nominal | Singleton | Union | Difference | Tuple | HashShape
 
     type accepts_mode = :strict | :gradual | :loose
 
@@ -58,6 +58,30 @@ module Rigor
       def inspect: () -> String
     end
 
+    class IntegerRange
+      NEG_INFINITY: Symbol
+      POS_INFINITY: Symbol
+      attr_reader min: (Integer | Symbol)
+      attr_reader max: (Integer | Symbol)
+      def initialize: ((Integer | Symbol) min, (Integer | Symbol) max) -> void
+      def universal?: () -> bool
+      def finite?: () -> bool
+      def cardinality: () -> (Integer | Float)
+      def covers?: (untyped value) -> bool
+      def lower: () -> Numeric
+      def upper: () -> Numeric
+      def describe: (?Symbol verbosity) -> String
+      def generic_description: () -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
     class Nominal
       attr_reader class_name: String
       attr_reader type_args: Array[Type::t]
@@ -101,6 +125,51 @@ module Rigor
       def inspect: () -> String
     end
 
+    class Difference
+      attr_reader base: Type::t
+      attr_reader removed: Type::t
+      def initialize: (Type::t base, Type::t removed) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class Refined
+      attr_reader base: Type::t
+      attr_reader predicate_id: Symbol
+      def initialize: (Type::t base, Symbol predicate_id) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def matches?: (untyped value) -> bool?
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class Intersection
+      attr_reader members: Array[Type::t]
+      def initialize: (Array[Type::t] members) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Top
+      def bot: () -> Bot
+      def dynamic: () -> Dynamic
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
     class Tuple
       attr_reader elements: Array[Type::t]
       def initialize: (Array[Type::t] elements) -> void
@@ -163,6 +232,27 @@ module Rigor
       def self?.nominal_of: (Module | String class_name_or_object, ?type_args: Array[Type::t]) -> Nominal
       def self?.singleton_of: (Module | String class_name_or_object) -> Singleton
       def self?.constant_of: (untyped value) -> Constant
+      def self?.difference: (Type::t base, Type::t removed) -> Difference
+      def self?.non_empty_string: () -> Difference
+      def self?.non_zero_int: () -> Difference
+      def self?.non_empty_array: (?Type::t element) -> Difference
+      def self?.non_empty_hash: (?Type::t key, ?Type::t value) -> Difference
+      def self?.refined: (Type::t base, Symbol predicate_id) -> Refined
+      def self?.lowercase_string: () -> Refined
+      def self?.uppercase_string: () -> Refined
+      def self?.numeric_string: () -> Refined
+      def self?.decimal_int_string: () -> Refined
+      def self?.octal_int_string: () -> Refined
+      def self?.hex_int_string: () -> Refined
+      def self?.intersection: (*Type::t members) -> Type::t
+      def self?.non_empty_lowercase_string: () -> Type::t
+      def self?.non_empty_uppercase_string: () -> Type::t
+      def self?.integer_range: ((Integer | Symbol) min, (Integer | Symbol) max) -> IntegerRange
+      def self?.positive_int: () -> IntegerRange
+      def self?.non_negative_int: () -> IntegerRange
+      def self?.negative_int: () -> IntegerRange
+      def self?.non_positive_int: () -> IntegerRange
+      def self?.universal_int: () -> IntegerRange
       def self?.tuple_of: (*Type::t elements) -> Tuple
       def self?.hash_shape_of: (?Hash[untyped, Type::t]? pairs, **untyped options) -> HashShape
       def self?.union: (*Type::t types) -> Type::t

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Rigor contributors
@@ -160,6 +160,15 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- data/builtins/ruby_core/array.yml
+- data/builtins/ruby_core/file.yml
+- data/builtins/ruby_core/hash.yml
+- data/builtins/ruby_core/io.yml
+- data/builtins/ruby_core/numeric.yml
+- data/builtins/ruby_core/range.yml
+- data/builtins/ruby_core/set.yml
+- data/builtins/ruby_core/string.yml
+- data/builtins/ruby_core/time.yml
 - exe/rigor
 - lib/rigor.rb
 - lib/rigor/analysis/check_rules.rb
@@ -169,6 +178,7 @@ files:
 - lib/rigor/analysis/runner.rb
 - lib/rigor/ast.rb
 - lib/rigor/ast/type_node.rb
+- lib/rigor/builtins/imported_refinements.rb
 - lib/rigor/cli.rb
 - lib/rigor/cli/type_of_command.rb
 - lib/rigor/cli/type_of_renderer.rb
@@ -182,6 +192,14 @@ files:
 - lib/rigor/environment/rbs_loader.rb
 - lib/rigor/inference/acceptance.rb
 - lib/rigor/inference/block_parameter_binder.rb
+- lib/rigor/inference/builtins/array_catalog.rb
+- lib/rigor/inference/builtins/hash_catalog.rb
+- lib/rigor/inference/builtins/method_catalog.rb
+- lib/rigor/inference/builtins/numeric_catalog.rb
+- lib/rigor/inference/builtins/range_catalog.rb
+- lib/rigor/inference/builtins/set_catalog.rb
+- lib/rigor/inference/builtins/string_catalog.rb
+- lib/rigor/inference/builtins/time_catalog.rb
 - lib/rigor/inference/closure_escape_analyzer.rb
 - lib/rigor/inference/coverage_scanner.rb
 - lib/rigor/inference/expression_typer.rb
@@ -189,6 +207,8 @@ files:
 - lib/rigor/inference/fallback_tracer.rb
 - lib/rigor/inference/method_dispatcher.rb
 - lib/rigor/inference/method_dispatcher/constant_folding.rb
+- lib/rigor/inference/method_dispatcher/file_folding.rb
+- lib/rigor/inference/method_dispatcher/iterator_dispatch.rb
 - lib/rigor/inference/method_dispatcher/overload_selector.rb
 - lib/rigor/inference/method_dispatcher/rbs_dispatch.rb
 - lib/rigor/inference/method_dispatcher/shape_dispatch.rb
@@ -210,9 +230,13 @@ files:
 - lib/rigor/type/bot.rb
 - lib/rigor/type/combinator.rb
 - lib/rigor/type/constant.rb
+- lib/rigor/type/difference.rb
 - lib/rigor/type/dynamic.rb
 - lib/rigor/type/hash_shape.rb
+- lib/rigor/type/integer_range.rb
+- lib/rigor/type/intersection.rb
 - lib/rigor/type/nominal.rb
+- lib/rigor/type/refined.rb
 - lib/rigor/type/singleton.rb
 - lib/rigor/type/top.rb
 - lib/rigor/type/tuple.rb