rigortype 0.0.3 → 0.0.4

data/lib/rigor/inference/builtins/time_catalog.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Time` catalog. Singleton — load once, consult during dispatch.
+      #
+      # Time is a pure-C built-in: the Init block in
+      # `references/ruby/time.c` registers the bulk of the surface,
+      # and the Ruby-side prelude `references/ruby/timev.rb`
+      # contributes the class-side constructors (`Time.now`,
+      # `Time.at`, `Time.new`) through Primitive cexpr stubs.
+      #
+      # Time receivers are not lifted to a `Constant` carrier today
+      # (there is no `Time` literal node — the closest is
+      # `Time.now` / `Time.new(...)`, which produce `Nominal[Time]`).
+      # The catalog wiring therefore mostly governs:
+      #
+      # 1. The size-projection-equivalent reader surface (`#year`,
+      #    `#month`, `#hour`, `#sec`, `#wday`, …) — RBS-declared
+      #    `Integer` is preserved through dispatch.
+      # 2. The blocklist below, which keeps the indirect-mutator
+      #    methods that the C-body classifier mis-flagged as
+      #    `:leaf` from ever folding through a hypothetical future
+      #    `Constant<Time>` carrier.
+      #
+      # The blocklist captures the false-positive `:leaf` entries
+      # whose helper functions the regex classifier did not
+      # recognise as mutators.
+      TIME_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/time.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Time" => Set[
+            # `time_init_copy` writes the `timew` and `vtm` slots on
+            # the receiver via `time_set_timew` / `time_set_vtm`.
+            # Classed `:leaf` because those setters are not in the
+            # mutator regex's helper list. Blocked for symmetry with
+            # String / Array / Range / Set initialize_copy entries.
+            :initialize_copy,
+            # `time_localtime_m` -> `time_localtime` calls
+            # `time_modify(time)` to mark the receiver mutable
+            # before rewriting its `vtm` cache and `tzmode`. The
+            # docstring is explicit ("converts time to local time
+            # in place"). The C-body classifier mis-flagged it as
+            # `:leaf` because `time_modify` is not in its mutator
+            # regex.
+            :localtime,
+            # `time_gmtime` (registered as both `gmtime` and `utc`
+            # against `rb_cTime`) follows the same in-place pattern
+            # as `time_localtime`: `time_modify(time)` then a
+            # `time_set_vtm` write and `TZMODE_SET_UTC`. Both
+            # selectors share the cfunc, so both must be blocked.
+            :gmtime, :utc
+          ]
+        }
+      )
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher/constant_folding.rb

@@ -4,6 +4,10 @@ require_relative "../../type"
 require_relative "../builtins/numeric_catalog"
 require_relative "../builtins/string_catalog"
 require_relative "../builtins/array_catalog"
+require_relative "../builtins/hash_catalog"
+require_relative "../builtins/range_catalog"
+require_relative "../builtins/set_catalog"
+require_relative "../builtins/time_catalog"
 
 module Rigor
   module Inference
@@ -626,17 +630,33 @@ module Rigor
           catalog.safe_for_folding?(class_name, method_name)
         end
 
+        # `(catalog, class_name)` per receiver class. The class_name
+        # is what each catalog's RBS-rooted entries are keyed by.
+        # `catalog_for` walks this table in declaration order so
+        # subclasses (Symbol < String) hit their dedicated entry
+        # before any base-class fallback would, and adding a new
+        # class is a one-line addition rather than another `when`
+        # arm on a growing case statement.
+        CATALOG_BY_CLASS = [
+          [Integer, [Builtins::NumericCatalog, "Integer"]],
+          [Float,   [Builtins::NumericCatalog, "Float"]],
+          [String,  [Builtins::STRING_CATALOG, "String"]],
+          [Symbol,  [Builtins::STRING_CATALOG, "Symbol"]],
+          [Array,   [Builtins::ARRAY_CATALOG,  "Array"]],
+          [Hash,    [Builtins::HASH_CATALOG,   "Hash"]],
+          [Range,   [Builtins::RANGE_CATALOG,  "Range"]],
+          [::Set,   [Builtins::SET_CATALOG,    "Set"]],
+          [Time,    [Builtins::TIME_CATALOG,   "Time"]]
+        ].freeze
+        private_constant :CATALOG_BY_CLASS
+
         # Returns `[catalog, class_name]` for receivers we have a
-        # catalog for; nil otherwise. The class_name is what the
-        # catalog's RBS-rooted entries are keyed by.
+        # catalog for; nil otherwise.
         def catalog_for(receiver_value)
-          case receiver_value
-          when Integer then [Builtins::NumericCatalog, "Integer"]
-          when Float   then [Builtins::NumericCatalog, "Float"]
-          when String  then [Builtins::STRING_CATALOG, "String"]
-          when Symbol  then [Builtins::STRING_CATALOG, "Symbol"]
-          when Array   then [Builtins::ARRAY_CATALOG,  "Array"]
+          CATALOG_BY_CLASS.each do |klass, entry|
+            return entry if receiver_value.is_a?(klass)
           end
+          nil
         end
 
         def unary_ops_for(receiver_value)

data/lib/rigor/inference/method_dispatcher/iterator_dispatch.rb

@@ -27,7 +27,7 @@ module Rigor
       # - `a.downto(b) { |i| … }` yields the same domain `[b, a]`,
       #   just iterated in reverse. Lower bound from the
       #   argument, upper bound from the receiver.
-      module IteratorDispatch
+      module IteratorDispatch # rubocop:disable Metrics/ModuleLength
         module_function
 
         # @return [Array<Rigor::Type>, nil] block-param types, or
@@ -37,6 +37,7 @@ module Rigor
           when :times then times_block_params(receiver)
           when :upto  then upto_block_params(receiver, args.first)
           when :downto then downto_block_params(receiver, args.first)
+          when :each_with_index then each_with_index_block_params(receiver)
           end
         end
 
@@ -62,6 +63,107 @@ module Rigor
           [build_index_range(lower_bound_of(end_arg), upper_bound_of(receiver))]
         end
 
+        # Generalised iterator: every Enumerable-shaped collection
+        # in v0.0.4 yields `(element, index)` where the index is
+        # always `non-negative-int`. The element comes from the
+        # receiver's shape:
+        #
+        # - `Array[T]` / `Set[T]` / `Range[T]`              → T
+        # - `Tuple[A, B, C]`                                → A | B | C
+        #   (empty tuple cannot iterate, but we conservatively
+        #   fall through to RBS so a missing rule never throws)
+        # - `Hash[K, V]` / `HashShape{...}`                 → Tuple[K, V]
+        #   (Ruby yields `[key, value]` pairs as the element)
+        # - `Constant<Array>` / `Constant<Range>` / `Constant<Set>`
+        #                                                   → corresponding Constant element
+        #
+        # Receivers we cannot project (Top, Dynamic, unknown
+        # nominals, IO, …) decline so the RBS tier still answers
+        # — its element type is correct, only the index would
+        # widen to plain Integer.
+        def each_with_index_block_params(receiver)
+          element = element_type_of(receiver)
+          return nil if element.nil?
+
+          [element, Type::Combinator.non_negative_int]
+        end
+
+        ELEMENT_BY_NOMINAL = {
+          "Array" => :nominal_unary_element,
+          "Set" => :nominal_unary_element,
+          "Range" => :nominal_unary_element,
+          "Hash" => :nominal_hash_pair_element
+        }.freeze
+        private_constant :ELEMENT_BY_NOMINAL
+
+        def element_type_of(receiver)
+          case receiver
+          when Type::Tuple then tuple_element(receiver)
+          when Type::HashShape then hash_shape_pair_element(receiver)
+          when Type::Nominal then nominal_element(receiver)
+          when Type::Constant then constant_element(receiver)
+          end
+        end
+
+        def tuple_element(tuple)
+          return nil if tuple.elements.empty?
+          return tuple.elements.first if tuple.elements.size == 1
+
+          Type::Combinator.union(*tuple.elements)
+        end
+
+        def hash_shape_pair_element(shape)
+          return nil if shape.pairs.empty?
+
+          key = Type::Combinator.union(*shape.pairs.keys.map { |k| Type::Combinator.constant_of(k) })
+          value = Type::Combinator.union(*shape.pairs.values)
+          Type::Combinator.tuple_of(key, value)
+        end
+
+        def nominal_element(nominal)
+          handler = ELEMENT_BY_NOMINAL[nominal.class_name]
+          return nil unless handler
+
+          send(handler, nominal)
+        end
+
+        def nominal_unary_element(nominal)
+          nominal.type_args.first
+        end
+
+        def nominal_hash_pair_element(nominal)
+          key, value = nominal.type_args
+          return nil if key.nil? || value.nil?
+
+          Type::Combinator.tuple_of(key, value)
+        end
+
+        def constant_element(constant)
+          case constant.value
+          when Array
+            return nil if constant.value.empty?
+
+            Type::Combinator.union(*constant.value.map { |v| Type::Combinator.constant_of(v) })
+          when Range
+            range_constant_element(constant.value)
+          end
+        end
+
+        def range_constant_element(range)
+          beg = range.begin
+          en  = range.end
+          return Type::Combinator.constant_of(beg) if beg.is_a?(Integer) && beg == en
+
+          if beg.is_a?(Integer) && en.is_a?(Integer)
+            upper = range.exclude_end? ? en - 1 : en
+            return build_index_range(beg, upper)
+          end
+
+          # Mixed / non-integer ranges decline: the dispatcher
+          # falls through to RBS's element-type answer.
+          nil
+        end
+
         # `Constant<Integer>`, `IntegerRange`, and `Nominal[Integer]`
         # all participate. Non-integer types (Float, String, …) and
         # `Top`/`Dynamic` decline so the RBS tier answers.

data/lib/rigor/inference/method_dispatcher/overload_selector.rb

@@ -53,13 +53,22 @@ module Rigor
           overloads = method_definition.method_types
           return nil if overloads.empty?
 
+          # `rigor:v1:param: <name> <refinement>` annotations on
+          # this method override the RBS-declared parameter type
+          # at the matching name. The map is consumed inside
+          # `accepts_param?` so overload selection sees the
+          # tighter type when filtering candidates by argument
+          # compatibility.
+          param_overrides = RbsExtended.param_type_override_map(method_definition)
+
           match = find_matching_overload(
             overloads,
             arg_types: arg_types,
             self_type: self_type,
             instance_type: instance_type,
             type_vars: type_vars,
-            block_required: block_required
+            block_required: block_required,
+            param_overrides: param_overrides
           )
           return match if match
           return overloads.find { |mt| overload_has_block?(mt) } if block_required
@@ -76,7 +85,8 @@ module Rigor
           private
 
           # rubocop:disable Metrics/ParameterLists
-          def find_matching_overload(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:)
+          def find_matching_overload(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:,
+                                     param_overrides:)
             overloads.find do |method_type|
               next false if block_required && !OverloadSelector.overload_has_block?(method_type)
 
@@ -85,13 +95,15 @@ module Rigor
                 arg_types,
                 self_type: self_type,
                 instance_type: instance_type,
-                type_vars: type_vars
+                type_vars: type_vars,
+                param_overrides: param_overrides
               )
             end
           end
           # rubocop:enable Metrics/ParameterLists
 
-          def matches?(method_type, arg_types, self_type:, instance_type:, type_vars:)
+          # rubocop:disable Metrics/ParameterLists
+          def matches?(method_type, arg_types, self_type:, instance_type:, type_vars:, param_overrides:)
             return false if method_type.respond_to?(:type_params) && rejects_keyword_required?(method_type)
 
             fun = method_type.type
@@ -104,10 +116,12 @@ module Rigor
                 arg,
                 self_type: self_type,
                 instance_type: instance_type,
-                type_vars: type_vars
+                type_vars: type_vars,
+                param_overrides: param_overrides
               )
             end
           end
+          # rubocop:enable Metrics/ParameterLists
 
           # Slice 4 phase 2c does not pass keyword arguments through the
           # call site (caller passes only positional `arg_types`). An
@@ -152,8 +166,9 @@ module Rigor
             head
           end
 
-          def accepts_param?(param, arg, self_type:, instance_type:, type_vars:)
-            param_type = RbsTypeTranslator.translate(
+          # rubocop:disable Metrics/ParameterLists
+          def accepts_param?(param, arg, self_type:, instance_type:, type_vars:, param_overrides:)
+            param_type = param_overrides[param.name] || RbsTypeTranslator.translate(
               param.type,
               self_type: self_type,
               instance_type: instance_type,
@@ -162,6 +177,7 @@ module Rigor
             result = param_type.accepts(arg, mode: :gradual)
             result.yes? || result.maybe?
           end
+          # rubocop:enable Metrics/ParameterLists
         end
       end
     end

data/lib/rigor/inference/method_dispatcher/shape_dispatch.rb

@@ -88,14 +88,25 @@ module Rigor
 
         # @return [Rigor::Type, nil] the precise element/value type, or
         #   `nil` to defer to the next dispatcher tier.
+        # Per-carrier dispatch table. Adding a new carrier here
+        # is a one-row change; the helper methods stay private.
+        # Anonymous Type subclasses are not expected.
+        RECEIVER_HANDLERS = {
+          Type::Tuple => :dispatch_tuple,
+          Type::HashShape => :dispatch_hash_shape,
+          Type::Nominal => :dispatch_nominal_size,
+          Type::Difference => :dispatch_difference,
+          Type::Refined => :dispatch_refined,
+          Type::Intersection => :dispatch_intersection
+        }.freeze
+        private_constant :RECEIVER_HANDLERS
+
         def try_dispatch(receiver:, method_name:, args:)
           args ||= []
-          case receiver
-          when Type::Tuple then dispatch_tuple(receiver, method_name, args)
-          when Type::HashShape then dispatch_hash_shape(receiver, method_name, args)
-          when Type::Nominal then dispatch_nominal_size(receiver, method_name, args)
-          when Type::Difference then dispatch_difference(receiver, method_name, args)
-          end
+          handler = RECEIVER_HANDLERS[receiver.class]
+          return nil unless handler
+
+          send(handler, receiver, method_name, args)
         end
 
         # Tightens `Array#size` / `Array#length` / `String#length` /
@@ -220,6 +231,124 @@ module Rigor
             Type::Combinator.positive_int
           end
 
+          # Predicate-subset projections over a `Refined[base,
+          # predicate]` receiver. Today the catalogue is the
+          # String case-normalisation pair: `s.downcase` over a
+          # `lowercase-string` receiver folds to the same
+          # carrier (already lowercase), and `s.upcase` lifts a
+          # `lowercase-string` to `uppercase-string`. Symmetric
+          # rules apply with the predicates swapped. Numeric-
+          # string idempotence over `#downcase` / `#upcase` is
+          # also recognised because a numeric string equals its
+          # own case-normalisation.
+          #
+          # For methods this tier does not have a refinement-
+          # specific rule for, projection delegates to
+          # `dispatch_nominal_size` so size-returning calls on
+          # a `Refined[String, *]` still tighten to
+          # `non_negative_int`.
+          REFINED_STRING_PROJECTIONS = {
+            %i[lowercase downcase] => :refined_self,
+            %i[lowercase upcase] => :uppercase_string,
+            %i[uppercase upcase] => :refined_self,
+            %i[uppercase downcase] => :lowercase_string,
+            %i[numeric downcase] => :refined_self,
+            %i[numeric upcase] => :refined_self,
+            # Digit-only strings are case-invariant; the prefix
+            # letters in `0o…` / `0x…` are accepted by the
+            # predicate in either case so the predicate-subset
+            # is preserved across `#downcase` / `#upcase` even
+            # though the value-set element changes.
+            %i[decimal_int downcase] => :refined_self,
+            %i[decimal_int upcase] => :refined_self,
+            %i[octal_int downcase] => :refined_self,
+            %i[octal_int upcase] => :refined_self,
+            %i[hex_int downcase] => :refined_self,
+            %i[hex_int upcase] => :refined_self
+          }.freeze
+          private_constant :REFINED_STRING_PROJECTIONS
+
+          def dispatch_refined(refined, method_name, args)
+            base = refined.base
+            return nil unless base.is_a?(Type::Nominal)
+
+            if base.class_name == "String" && args.empty?
+              precise = refined_string_projection(refined, method_name)
+              return precise if precise
+            end
+
+            dispatch_nominal_size(base, method_name, args)
+          end
+
+          def refined_string_projection(refined, method_name)
+            handler = REFINED_STRING_PROJECTIONS[[refined.predicate_id, method_name]]
+            return nil unless handler
+
+            case handler
+            when :refined_self then refined
+            when :uppercase_string then Type::Combinator.uppercase_string
+            when :lowercase_string then Type::Combinator.lowercase_string
+            end
+          end
+
+          # Projects a method call over an `Intersection[M1, …]`
+          # receiver by collecting each member's projection and
+          # combining the results. The set-theoretic identity is
+          # `M(A ∩ B) ⊆ M(A) ∩ M(B)`, so the meet of the per-member
+          # projections is sound. Combining is best-effort:
+          #
+          # - If every result is a `Type::IntegerRange`, return
+          #   their bounded-integer meet (max of lower bounds, min
+          #   of upper bounds). This catches the common
+          #   `(non_empty_string ∩ lowercase_string).size`
+          #   pattern where one member projects to `positive-int`
+          #   and the other to `non-negative-int`; the meet is
+          #   `positive-int`.
+          # - Otherwise return the first non-nil result. A richer
+          #   meet (e.g. of Difference + Refined results when both
+          #   project) is left for a future slice; the carrier
+          #   stays sound because every member's projection is
+          #   already a superset of the true intersection.
+          #
+          # Returns nil when no member projects, so the caller
+          # falls through to the next dispatcher tier.
+          def dispatch_intersection(intersection, method_name, args)
+            results = intersection.members.filter_map do |member|
+              ShapeDispatch.try_dispatch(receiver: member, method_name: method_name, args: args)
+            end
+
+            case results.size
+            when 0 then nil
+            when 1 then results.first
+            else combine_intersection_results(results)
+            end
+          end
+
+          def combine_intersection_results(results)
+            return narrow_integer_ranges(results) if results.all?(Type::IntegerRange)
+
+            results.first
+          end
+
+          # Compute the bounded-integer meet of two or more
+          # `IntegerRange` carriers. We compare via the numeric
+          # `lower` / `upper` accessors (`-Float::INFINITY` /
+          # `Float::INFINITY` for the symbolic ends), then map
+          # back to the symbolic-bound representation
+          # `IntegerRange.new` expects. The disjoint-meet case
+          # cannot arise from sound member-wise projections in
+          # v0.0.4 but is guarded defensively to keep the
+          # carrier total.
+          def narrow_integer_ranges(ranges)
+            numeric_low = ranges.map(&:lower).max
+            numeric_high = ranges.map(&:upper).min
+            return Type::Combinator.bot if numeric_low > numeric_high
+
+            min = numeric_low == -Float::INFINITY ? Type::IntegerRange::NEG_INFINITY : numeric_low.to_i
+            max = numeric_high == Float::INFINITY ? Type::IntegerRange::POS_INFINITY : numeric_high.to_i
+            Type::Combinator.integer_range(min, max)
+          end
+
           def tuple_first(tuple, _method_name, args)
             return nil unless args.empty?
             return Type::Combinator.constant_of(nil) if tuple.elements.empty?

data/lib/rigor/inference/method_parameter_binder.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "../type"
+require_relative "../rbs_extended"
 require_relative "rbs_type_translator"
 
 module Rigor
@@ -59,10 +60,13 @@ module Rigor
         rbs_method = lookup_rbs_method(def_node)
         return types unless rbs_method
 
-        method_types = rbs_method.method_types
-        return types if method_types.empty?
-
-        apply_rbs_overloads(types, slots, method_types)
+        apply_rbs_overloads(types, slots, rbs_method.method_types) unless rbs_method.method_types.empty?
+        # `rigor:v1:param: <name> <refinement>` annotations
+        # tighten the bound type for matching slots. Applied
+        # after the RBS-overload pass so the override is the
+        # authoritative answer regardless of what the RBS
+        # signature declared.
+        apply_param_overrides(types, slots, rbs_method)
         types
       end
 
@@ -165,6 +169,27 @@ module Rigor
         end
       end
 
+      # Reads the override map off the method's annotations and
+      # replaces the binding for any slot whose name appears in
+      # the map. Anonymous slots are skipped (no name to match).
+      # The override is used verbatim — no `:rest_*` re-wrapping —
+      # so authors who tighten a `*rest` parameter to e.g.
+      # `non-empty-array[Integer]` describe the parameter binding
+      # they actually want, not its element type.
+      def apply_param_overrides(types, slots, rbs_method)
+        override_map = RbsExtended.param_type_override_map(rbs_method)
+        return if override_map.empty?
+
+        slots.each do |slot|
+          next if slot.name.nil?
+
+          override = override_map[slot.name]
+          next if override.nil?
+
+          types[slot.name] = override
+        end
+      end
+
       def collect_translated_types(method_types, slot)
         rbs_types = method_types.flat_map do |mt|
           t = rbs_type_for_slot(mt.type, slot)

data/lib/rigor/inference/narrowing.rb

@@ -1029,6 +1029,8 @@ module Rigor
         # the effect's `negative?` flag. Shared between
         # predicate-if-* and assert-if-* application paths.
         def narrow_for_effect(current, effect, environment)
+          return effect.refinement_type if effect.respond_to?(:refinement?) && effect.refinement?
+
           if effect.negative?
             narrow_not_class(current, effect.class_name, exact: false, environment: environment)
           else

data/lib/rigor/inference/statement_evaluator.rb

@@ -894,6 +894,8 @@ module Rigor
       end
 
       def narrow_for_assert_effect(current_type, effect, environment)
+        return effect.refinement_type if effect.refinement?
+
         if effect.negative?
           Narrowing.narrow_not_class(current_type, effect.class_name, exact: false, environment: environment)
         else