rigortype 0.0.9 → 0.1.1

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

@@ -8,12 +8,21 @@ module Rigor
       # Dispatcher tier that lifts string-composition results into
       # the `literal-string` carrier when every operand is itself
       # literal-bearing. Sits between {ConstantFolding} (which
-      # handles all-Constant cases) and {ShapeDispatch}; runs only
-      # for `String#+` / `String#*` / `String#<<` / `String#concat`
-      # calls whose inputs the ConstantFolding tier could not fold
-      # to a precise `Constant<String>` (e.g. one operand is
-      # `literal-string` rather than `Constant<String>`, or the
-      # multiplication exceeds the constant-fold size cap).
+      # handles all-Constant cases) and {ShapeDispatch}; runs for:
+      #
+      # - `String#+` / `String#*` / `String#<<` / `String#concat`
+      #   on string-typed receivers whose inputs the
+      #   ConstantFolding tier could not fold to a precise
+      #   `Constant<String>` (e.g. one operand is `literal-string`
+      #   rather than `Constant<String>`, or the multiplication
+      #   exceeds the constant-fold size cap).
+      # - `Array#join` on `Tuple[…]` receivers whose every element
+      #   plus the separator argument (when given) is
+      #   literal-bearing.
+      # - `Kernel#format` / `Kernel#sprintf` (any receiver) and
+      #   `String#%` (literal-bearing receiver) when every value
+      #   argument is literal-bearing or a Type::Constant of any
+      #   value.
       #
       # Result rule:
       #
@@ -27,6 +36,12 @@ module Rigor
       #   literal-bearing too.
       # - `*`: receiver MUST be literal-bearing; argument MUST be
       #   integer-typed. The result is `literal-string`.
+      # - `join`: receiver MUST be `Tuple[…]` with every element
+      #   literal-string-compatible; the optional separator
+      #   argument MUST also be literal-string-compatible.
+      #   Result: `literal-string`. Empty `Tuple[]` lifts too —
+      #   `[].join` is the empty string at runtime, which is
+      #   literal-bearing trivially.
       #
       # Other receiver / argument shapes decline so the next tier
       # (ShapeDispatch / FileFolding / RbsDispatch) takes over and
@@ -36,10 +51,40 @@ module Rigor
         module_function
 
         CONCAT_METHODS = %i[+ << concat].freeze
-        private_constant :CONCAT_METHODS
+        FORMAT_METHODS = %i[format sprintf].freeze
+        # v0.1.1 Track 1 slice 5a — methods that, called with no
+        # arguments on a literal-bearing receiver, return a value
+        # that is also literal-bearing. `#strip` / `#lstrip` /
+        # `#rstrip` / `#chomp` (no-arg) / `#chop` strip a known
+        # subset of characters from the ends, so the survivors
+        # are always a substring of an already-literal value.
+        # `#scrub` (no-arg) replaces invalid bytes; a literal-string
+        # value comes from source code and is always valid UTF-8,
+        # so the result is identical to the receiver. None of
+        # these preserve `non-empty-string`-ness (e.g. `"   ".strip
+        # == ""`); the carrier collapses from `non-empty-literal-string`
+        # down to plain `literal-string`.
+        LITERAL_PRESERVING_METHODS = %i[strip lstrip rstrip chomp chop scrub].freeze
+        # v0.1.1 Track 1 slice 5c — width-padding methods. `center`
+        # / `ljust` / `rjust` take a `width` Integer plus an
+        # optional literal padding `String`. When the receiver
+        # and the (default or supplied) padding are both
+        # literal-bearing, the result is literal-bearing too.
+        WIDTH_PADDING_METHODS = %i[center ljust rjust].freeze
+        private_constant :CONCAT_METHODS, :FORMAT_METHODS,
+                         :LITERAL_PRESERVING_METHODS, :WIDTH_PADDING_METHODS
+
+        def try_dispatch(receiver:, method_name:, args:, **) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          return fold_array_join(receiver, args) if method_name == :join
+          return fold_format(args) if FORMAT_METHODS.include?(method_name)
 
-        def try_dispatch(receiver:, method_name:, args:, **)
           return nil unless Type::Combinator.literal_string_compatible?(receiver)
+
+          return fold_string_percent(args) if method_name == :%
+          if args.empty?
+            return LITERAL_PRESERVING_METHODS.include?(method_name) ? Type::Combinator.literal_string : nil
+          end
+          return fold_width_pad(args) if WIDTH_PADDING_METHODS.include?(method_name)
           return nil unless args.size == 1
 
           if CONCAT_METHODS.include?(method_name)
@@ -49,6 +94,23 @@ module Rigor
           end
         end
 
+        # `String#center` / `#ljust` / `#rjust` — first argument is
+        # the target width (Integer-typed), optional second
+        # argument is the padding string (must be literal-bearing
+        # for the result to stay literal). The default padding
+        # (a space) is always literal so the no-second-arg form
+        # passes through. Width is allowed to be any Integer
+        # because Ruby's runtime accepts negative widths and
+        # widths smaller than the receiver's length without
+        # raising.
+        def fold_width_pad(args)
+          return nil unless [1, 2].include?(args.size)
+          return nil unless integer_typed?(args[0])
+          return nil if args.size == 2 && !Type::Combinator.literal_string_compatible?(args[1])
+
+          Type::Combinator.literal_string
+        end
+
         def fold_concat(arg_type)
           return nil unless Type::Combinator.literal_string_compatible?(arg_type)
 
@@ -62,6 +124,69 @@ module Rigor
           Type::Combinator.literal_string
         end
 
+        # `[lit, lit].join(sep)` — receiver must be a Tuple
+        # whose every element is literal-bearing; separator
+        # (when given) must be literal-bearing too. Multi-arg
+        # forms / `Array#join(*args)` splat shapes don't reach
+        # here because the dispatcher only routes through this
+        # tier when the call resolves to a single named method.
+        def fold_array_join(receiver, args)
+          return nil unless receiver.is_a?(Type::Tuple)
+          return nil unless receiver.elements.all? { |el| Type::Combinator.literal_string_compatible?(el) }
+          return nil unless args.size <= 1
+          return nil if args.size == 1 && !Type::Combinator.literal_string_compatible?(args.first)
+
+          Type::Combinator.literal_string
+        end
+
+        # `format("hello %s", lit)` / `sprintf(...)` — template
+        # plus every value argument must be literal-bearing
+        # ({Type::Combinator.literal_string_compatible?}) or a
+        # `Type::Constant` of any value (Constants are always
+        # provably literal). The template arg specifically must
+        # be literal-bearing — a Constant<Integer> first arg
+        # would not be a valid format template, so the
+        # `Type::Constant` allowance applies only to subsequent
+        # value args.
+        def fold_format(args)
+          return nil if args.empty?
+          return nil unless Type::Combinator.literal_string_compatible?(args.first)
+          return nil unless args.drop(1).all? { |arg| literal_or_constant?(arg) }
+
+          Type::Combinator.literal_string
+        end
+
+        # `"foo %s" % "x"` / `"foo %s" % ["x", "y"]` — receiver
+        # is the template (already verified literal-bearing by
+        # the caller); arg is either:
+        #
+        # - a single literal-bearing string / Constant value, or
+        # - a Tuple whose every element is literal-bearing or a
+        #   Constant.
+        #
+        # Hash-form `%` (e.g. `"%{name}" % {name: "x"}`) is not
+        # yet folded — the analyzer's HashShape carrier could
+        # support this, but the v0.0.x catalogue declines and
+        # widens to Nominal[String].
+        def fold_string_percent(args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          if arg.is_a?(Type::Tuple)
+            return nil unless arg.elements.all? { |el| literal_or_constant?(el) }
+
+            return Type::Combinator.literal_string
+          end
+
+          return nil unless literal_or_constant?(arg)
+
+          Type::Combinator.literal_string
+        end
+
+        def literal_or_constant?(type)
+          Type::Combinator.literal_string_compatible?(type) || type.is_a?(Type::Constant)
+        end
+
         def integer_typed?(type)
           case type
           when Type::Constant then type.value.is_a?(Integer)
@@ -80,7 +205,9 @@ module Rigor
           type.is_a?(Type::Constant) && type.value.is_a?(Integer) && type.value.negative?
         end
 
-        private_class_method :fold_concat, :fold_repeat, :integer_typed?
+        private_class_method :fold_concat, :fold_repeat, :fold_array_join,
+                             :fold_format, :fold_string_percent, :fold_width_pad,
+                             :literal_or_constant?, :integer_typed?
       end
     end
   end

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

@@ -243,7 +243,13 @@ module Rigor
 
           # rubocop:disable Metrics/ParameterLists
           def translate_return_type(method_definition, class_name:, kind:, args:, type_vars:, block_type:)
-            override = RbsExtended.read_return_type_override(method_definition)
+            # Slice 4b-3 (ADR-7 § "Slice 4-A/4-B") — read the
+            # return-type override through the merger so future
+            # plugin / `:rbs_extended` bundles that also assert a
+            # `return_type` slot at this call site compose with
+            # the RBS::Extended directive instead of silently
+            # racing it.
+            override = merged_return_type(method_definition)
             return override if override
 
             instance_type = Type::Combinator.nominal_of(class_name)
@@ -274,6 +280,20 @@ module Rigor
           end
           # rubocop:enable Metrics/ParameterLists
 
+          # ADR-7 § "Slice 4-A/4-B" — folds the
+          # `RBS::Extended` `return:` directive (and any
+          # other `return_type`-bearing contribution future
+          # slices add at this call site) through the merger
+          # before consuming. Returns the merged return type
+          # or nil when no contribution overrides the
+          # RBS-declared return.
+          def merged_return_type(method_definition)
+            contribution = RbsExtended.read_flow_contribution(method_definition)
+            return nil if contribution.nil?
+
+            Rigor::FlowContribution::Merger.merge([contribution]).return_type
+          end
+
           # When a block type is supplied, locate the method-level
           # type parameter that the selected overload's block return
           # type references and bind it to `block_type`. The

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

@@ -122,10 +122,25 @@ module Rigor
           Type::Nominal => :dispatch_nominal_size,
           Type::Difference => :dispatch_difference,
           Type::Refined => :dispatch_refined,
-          Type::Intersection => :dispatch_intersection
+          Type::Intersection => :dispatch_intersection,
+          Type::IntegerRange => :dispatch_integer_range
         }.freeze
         private_constant :RECEIVER_HANDLERS
 
+        # v0.1.1 Track 1 slice 5b — `Integer#to_s(base)` on a
+        # non-negative `IntegerRange` receiver. The output of
+        # `n.to_s(b)` for `n >= 0` is digit-string-only (no
+        # leading sign), so when the base is in this table the
+        # result lifts to the matching imported refinement.
+        # Bases not listed (2, 36, ...) keep the v0.1.0 baseline
+        # since Rigor has no carrier for the resulting alphabet.
+        TO_S_BASE_REFINEMENTS = {
+          10 => :decimal_int_string,
+          8 => :octal_int_string,
+          16 => :hex_int_string
+        }.freeze
+        private_constant :TO_S_BASE_REFINEMENTS
+
         def try_dispatch(receiver:, method_name:, args:)
           args ||= []
           handler = RECEIVER_HANDLERS[receiver.class]
@@ -184,6 +199,42 @@ module Rigor
             Type::Combinator.non_negative_int
           end
 
+          # `IntegerRange#to_s` precision (v0.1.1 Track 1 slice 5b).
+          # When the range's lower bound is `>= 0`, every member is
+          # a non-negative integer and `to_s(base)` returns a
+          # digit-string with no leading sign. The result lifts to
+          # the matching imported refinement (`decimal-int-string`
+          # for base 10, `octal-int-string` for 8, `hex-int-string`
+          # for 16). Signed ranges fall through (the result could
+          # carry a `-` sign that no Rigor refinement currently
+          # captures), as do bases without a digit-only refinement.
+          def dispatch_integer_range(range, method_name, args)
+            return nil unless method_name == :to_s
+            return nil unless range.lower >= 0
+
+            base = base_argument(args)
+            return nil if base.nil?
+
+            refinement = TO_S_BASE_REFINEMENTS[base]
+            return nil if refinement.nil?
+
+            Type::Combinator.public_send(refinement)
+          end
+
+          # `to_s` with no argument defaults to base 10. With one
+          # argument, the value MUST be a `Constant<Integer>` to
+          # be statically known. Anything else (Nominal[Integer]
+          # arg, multi-arg, etc.) declines.
+          def base_argument(args)
+            return 10 if args.empty?
+            return nil unless args.size == 1
+
+            arg = args.first
+            return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Integer)
+
+            arg.value
+          end
+
           # Refinement-aware projections over a `Difference[base,
           # removed]` receiver. When the removed value is the
           # empty witness of the base (`Constant[""]` for
@@ -289,7 +340,21 @@ module Rigor
             %i[octal_int downcase] => :refined_self,
             %i[octal_int upcase] => :refined_self,
             %i[hex_int downcase] => :refined_self,
-            %i[hex_int upcase] => :refined_self
+            %i[hex_int upcase] => :refined_self,
+            # v0.1.1 Track 1 slice 2 — `to_i` / `to_int` on a
+            # known digit-only string. `decimal-int-string`
+            # (`/\A\d+\z/`) and `numeric-string` (Rigor's
+            # numeric-string predicate, ASCII digits) are
+            # predicates over digit-only strings, so the parse
+            # is total over the carrier domain and the result
+            # is always `>= 0`. `non-negative-int` is the
+            # tightest carrier that captures both the lower
+            # bound and the integer-ness without inventing a
+            # narrower carrier.
+            %i[decimal_int to_i] => :non_negative_int,
+            %i[decimal_int to_int] => :non_negative_int,
+            %i[numeric to_i] => :non_negative_int,
+            %i[numeric to_int] => :non_negative_int
           }.freeze
           private_constant :REFINED_STRING_PROJECTIONS
 
@@ -313,6 +378,7 @@ module Rigor
             when :refined_self then refined
             when :uppercase_string then Type::Combinator.uppercase_string
             when :lowercase_string then Type::Combinator.lowercase_string
+            when :non_negative_int then Type::Combinator.non_negative_int
             end
           end
 

data/lib/rigor/inference/method_dispatcher.rb

@@ -2,6 +2,8 @@
 
 require_relative "../reflection"
 require_relative "../type"
+require_relative "../flow_contribution"
+require_relative "../flow_contribution/merger"
 require_relative "method_dispatcher/constant_folding"
 require_relative "method_dispatcher/literal_string_folding"
 require_relative "method_dispatcher/shape_dispatch"
@@ -59,12 +61,25 @@ module Rigor
       # @param environment [Rigor::Environment, nil] required for
       #   RBS-backed dispatch; when nil only constant folding can fire.
       # @return [Rigor::Type, nil] inferred result type, or `nil` for "no rule".
-      def dispatch(receiver_type:, method_name:, arg_types:, block_type: nil, environment: nil)
+      def dispatch(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/ParameterLists
+                   block_type: nil, environment: nil,
+                   call_node: nil, scope: nil)
         return nil if receiver_type.nil?
 
         precise = dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type)
         return precise if precise
 
+        # v0.1.1 Track 2 slice 7 — plugin return-type contribution
+        # tier. Sits ahead of `RbsDispatch` so a plugin that
+        # understands a domain-specific dispatch (e.g. an
+        # `ActiveRecord::Base.find` returning `Nominal[<resolved
+        # model>]`) wins over the RBS-projected envelope. Only
+        # consults the registry when both `call_node` and `scope`
+        # are supplied — the dispatcher's own internal callers
+        # (per-element block fold, etc.) skip this tier.
+        plugin_result = try_plugin_contribution(call_node, scope)
+        return plugin_result if plugin_result
+
         rbs_result = RbsDispatch.try_dispatch(
           receiver: receiver_type, method_name: method_name, args: arg_types,
           environment: environment, block_type: block_type
@@ -85,6 +100,40 @@ module Rigor
         try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type)
       end
 
+      # ADR-2 § "Flow Contribution Bundle" / v0.1.1 Track 2
+      # slice 7. Walks every loaded plugin's
+      # `#flow_contribution_for(call_node:, scope:)` hook,
+      # collects the non-nil `FlowContribution` bundles, merges
+      # them through `FlowContribution::Merger`, and returns
+      # the merged `return_type` slot (or nil when no plugin
+      # contributed a return type).
+      #
+      # Plugins whose hook raises have their contribution
+      # silently dropped for this call so the dispatch chain
+      # keeps moving — the run-level diagnostic envelope (per
+      # ADR-2 § "Plugin Trust and I/O Policy") is owned by
+      # `Analysis::Runner#plugin_emitted_diagnostics`.
+      def try_plugin_contribution(call_node, scope)
+        return nil if call_node.nil? || scope.nil?
+
+        registry = scope.environment&.plugin_registry
+        return nil if registry.nil? || registry.empty?
+
+        contributions = collect_plugin_contributions(registry, call_node, scope)
+        return nil if contributions.empty?
+
+        FlowContribution::Merger.merge(contributions).return_type
+      end
+
+      def collect_plugin_contributions(registry, call_node, scope)
+        registry.plugins.filter_map do |plugin|
+          contribution = plugin.flow_contribution_for(call_node: call_node, scope: scope)
+          contribution.is_a?(FlowContribution) ? contribution : nil
+        rescue StandardError
+          nil
+        end
+      end
+
       # Runs the precision tiers (constant fold, shape dispatch,
       # file-path fold, block fold) in order and returns the first
       # non-nil answer. Each tier owns its own receiver/argument

data/lib/rigor/inference/multi_target_binder.rb

@@ -131,6 +131,8 @@ module Rigor
         end
 
         def bind_rest_target(splat_node, type, bindings)
+          return unless splat_node.is_a?(Prism::SplatNode)
+
           expression = splat_node.expression
           case expression
           when Prism::LocalVariableTargetNode, Prism::RequiredParameterNode