rigortype 0.0.2 → 0.0.4

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

@@ -88,14 +88,51 @@ 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)
-          end
+          handler = RECEIVER_HANDLERS[receiver.class]
+          return nil unless handler
+
+          send(handler, receiver, method_name, args)
         end
 
+        # Tightens `Array#size` / `Array#length` / `String#length` /
+        # `String#bytesize` / `Hash#size` etc. on a `Nominal` receiver
+        # from the RBS-declared `Integer` to `non_negative_int`. The
+        # tier ahead of RBS sees the more precise carrier so
+        # downstream narrowing (`if size > 0; …`) actually has a
+        # range to intersect with.
+        SIZE_RETURNING_NOMINALS = {
+          "Array" => %i[size length count],
+          "String" => %i[length size bytesize],
+          "Hash" => %i[size length count],
+          "Set" => %i[size length count],
+          "Range" => %i[size length count]
+        }.freeze
+        private_constant :SIZE_RETURNING_NOMINALS
+
+        # When the difference removes the empty value of the
+        # base type (`Constant[""]`, `Constant[0]`, an empty
+        # Tuple, an empty HashShape), `size` / `length` /
+        # `count` MUST be `positive-int` (the base's
+        # non-negative range minus the removed point's `0`),
+        # and `empty?` / `zero?` MUST be `Constant[false]`.
+        EMPTY_REMOVAL_BASES = %w[String Array Hash Set].freeze
+        private_constant :EMPTY_REMOVAL_BASES
+
         class << self
           private
 
@@ -113,6 +150,205 @@ module Rigor
             send(handler, shape, method_name, args)
           end
 
+          def dispatch_nominal_size(nominal, method_name, args)
+            return nil unless args.empty?
+
+            selectors = SIZE_RETURNING_NOMINALS[nominal.class_name]
+            return nil unless selectors&.include?(method_name)
+
+            Type::Combinator.non_negative_int
+          end
+
+          # Refinement-aware projections over a `Difference[base,
+          # removed]` receiver. When the removed value is the
+          # empty witness of the base (`Constant[""]` for
+          # String, `Tuple[]` for Array, `HashShape{}` for Hash,
+          # `Constant[0]` for Integer), the catalog tier knows:
+          #
+          #   ns.size                      # positive-int
+          #   ns.size == 0                 # Constant[false]   (via narrowing tier)
+          #   ns.empty?                    # Constant[false]
+          #   nzi.zero?                    # Constant[false]
+          #
+          # For any other base method, the difference is opaque
+          # to ShapeDispatch — we delegate to the base nominal
+          # so the size/length tier still answers the broader
+          # `non_negative_int` envelope where applicable.
+          def dispatch_difference(difference, method_name, args)
+            base = difference.base
+            return nil unless base.is_a?(Type::Nominal)
+
+            if removes_empty_witness?(difference)
+              precise = empty_removal_projection(base, method_name, args)
+              return precise if precise
+            end
+
+            dispatch_nominal_size(base, method_name, args)
+          end
+
+          EMPTY_WITNESS_PREDICATES = {
+            "String" => ->(removed) { removed.is_a?(Type::Constant) && removed.value == "" },
+            "Integer" => lambda { |removed|
+              removed.is_a?(Type::Constant) && removed.value.is_a?(Integer) && removed.value.zero?
+            },
+            "Array" => ->(removed) { removed.is_a?(Type::Tuple) && removed.elements.empty? },
+            "Hash" => ->(removed) { removed.is_a?(Type::HashShape) && removed.pairs.empty? }
+          }.freeze
+          private_constant :EMPTY_WITNESS_PREDICATES
+
+          def removes_empty_witness?(difference)
+            return false unless difference.base.is_a?(Type::Nominal)
+
+            predicate = EMPTY_WITNESS_PREDICATES[difference.base.class_name]
+            !!(predicate && predicate.call(difference.removed))
+          end
+
+          def empty_removal_projection(base, method_name, args)
+            return nil unless args.empty?
+
+            if %i[size length count bytesize].include?(method_name)
+              return size_returning_for_empty_removal(base, method_name)
+            end
+
+            empty_predicate_projection(base, method_name)
+          end
+
+          def empty_predicate_projection(base, method_name)
+            case method_name
+            when :empty?
+              base.class_name == "Integer" ? nil : Type::Combinator.constant_of(false)
+            when :zero?
+              base.class_name == "Integer" ? Type::Combinator.constant_of(false) : nil
+            end
+          end
+
+          def size_returning_for_empty_removal(base, method_name)
+            return nil if base.class_name == "Integer" # Integer has no size method on Difference
+
+            selectors = SIZE_RETURNING_NOMINALS[base.class_name]
+            return nil unless selectors&.include?(method_name)
+
+            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_dispatcher.rb

@@ -4,6 +4,8 @@ require_relative "../type"
 require_relative "method_dispatcher/constant_folding"
 require_relative "method_dispatcher/shape_dispatch"
 require_relative "method_dispatcher/rbs_dispatch"
+require_relative "method_dispatcher/iterator_dispatch"
+require_relative "method_dispatcher/file_folding"
 
 module Rigor
   module Inference
@@ -56,29 +58,12 @@ module Rigor
       def dispatch(receiver_type:, method_name:, arg_types:, block_type: nil, environment: nil)
         return nil if receiver_type.nil?
 
-        meta_result = try_meta_introspection(receiver_type, method_name)
-        return meta_result if meta_result
-
-        constant_result = ConstantFolding.try_fold(
-          receiver: receiver_type,
-          method_name: method_name,
-          args: arg_types
-        )
-        return constant_result if constant_result
-
-        shape_result = ShapeDispatch.try_dispatch(
-          receiver: receiver_type,
-          method_name: method_name,
-          args: arg_types
-        )
-        return shape_result if shape_result
+        precise = dispatch_precise_tiers(receiver_type, method_name, arg_types)
+        return precise if precise
 
         rbs_result = RbsDispatch.try_dispatch(
-          receiver: receiver_type,
-          method_name: method_name,
-          args: arg_types,
-          environment: environment,
-          block_type: block_type
+          receiver: receiver_type, method_name: method_name, args: arg_types,
+          environment: environment, block_type: block_type
         )
         return rbs_result if rbs_result
 
@@ -96,6 +81,21 @@ module Rigor
         try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type)
       end
 
+      # Runs the precision tiers (constant fold, shape dispatch,
+      # file-path fold) in order and returns the first non-nil
+      # answer. Each tier owns its own receiver/argument shape
+      # checks; a tier that does not recognise the receiver returns
+      # nil so the next tier can try. The RBS tier sits below this
+      # chain and is invoked by the outer `dispatch` method.
+      def dispatch_precise_tiers(receiver_type, method_name, arg_types)
+        meta_result = try_meta_introspection(receiver_type, method_name)
+        return meta_result if meta_result
+
+        ConstantFolding.try_fold(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          ShapeDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types)
+      end
+
       def try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type)
         return nil if environment.nil?
 
@@ -201,6 +201,13 @@ module Rigor
       def expected_block_param_types(receiver_type:, method_name:, arg_types:, environment: nil)
         return [] if receiver_type.nil?
 
+        iterator_result = IteratorDispatch.block_param_types(
+          receiver: receiver_type,
+          method_name: method_name,
+          args: arg_types
+        )
+        return iterator_result if iterator_result
+
         RbsDispatch.block_param_types(
           receiver: receiver_type,
           method_name: method_name,

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)