rigortype 0.1.0 → 0.1.2

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/narrowing.rb

@@ -7,6 +7,7 @@ require_relative "../type"
 require_relative "../environment"
 require_relative "../rbs_extended"
 require_relative "../analysis/fact_store"
+require_relative "../builtins/regex_refinement"
 
 module Rigor
   module Inference
@@ -746,20 +747,51 @@ module Rigor
         # `nil`. Subtract the dead half on each edge so callers
         # like `year.upcase` inside the truthy branch no longer
         # fire `possible-nil-receiver`.
+        #
+        # v0.1.1 Track 1 slice 1 — when the regex source is a
+        # statically known `RegularExpressionNode` and a named
+        # capture's body matches one of the curated shapes in
+        # {Rigor::Builtins::RegexRefinement::RULES}, the truthy
+        # branch narrows further than `String` to the matching
+        # imported refinement (e.g. `decimal-int-string` for
+        # `\d+`). Bodies outside the table fall back to the
+        # v0.1.0 baseline (plain `String`).
         def analyse_match_write(node, scope)
           string_t = Type::Combinator.nominal_of("String")
           nil_t = Type::Combinator.constant_of(nil)
+          refinements = match_write_capture_refinements(node)
           truthy = scope
           falsey = scope
           node.targets.each do |target|
             next unless target.is_a?(Prism::LocalVariableTargetNode)
 
-            truthy = truthy.with_local(target.name, string_t)
+            truthy = truthy.with_local(target.name, refinements[target.name] || string_t)
             falsey = falsey.with_local(target.name, nil_t)
           end
           [truthy, falsey]
         end
 
+        # Extracts `{ capture_name => Refinement }` for every named
+        # capture group in the `MatchWriteNode`'s wrapped `=~` call
+        # whose body the recogniser table accepts. Bodies that
+        # contain nested groups, anchors, alternation, or anything
+        # else outside the curated forms drop out and the caller
+        # falls back to plain `String`.
+        NAMED_CAPTURE_BODY_RE = /\(\?<([A-Za-z_][A-Za-z0-9_]*)>([^()|]*)\)/
+        private_constant :NAMED_CAPTURE_BODY_RE
+
+        def match_write_capture_refinements(node)
+          regex = node.call.is_a?(Prism::CallNode) ? node.call.receiver : nil
+          return {} unless regex.is_a?(Prism::RegularExpressionNode)
+
+          refinements = {}
+          regex.unescaped.scan(NAMED_CAPTURE_BODY_RE) do |name, body|
+            type = ::Rigor::Builtins::RegexRefinement.for_capture_body(body)
+            refinements[name.to_sym] = type if type
+          end
+          refinements
+        end
+
         # Recognised CallNode predicates:
         # - `recv.nil?` (Slice 6 phase 1, no args, no block)
         # - unary `!recv` (`name == :!`, no args, no block)
@@ -772,19 +804,82 @@ module Rigor
         # through to the no-narrowing fallback.
         def analyse_call(node, scope)
           return nil if node.block
-          return nil if node.receiver.nil?
 
-          shape_result = dispatch_call(node, scope, node.name)
-          return shape_result if shape_result
+          unless node.receiver.nil?
+            shape_result = dispatch_call(node, scope, node.name)
+            return shape_result if shape_result
+
+            # v0.1.1 Track 1 slice 4 — String predicate flow facts.
+            string_predicate_result = analyse_string_predicate(node, scope)
+            return string_predicate_result if string_predicate_result
+          end
 
           # Slice 7 phase 15 — RBS::Extended predicate
           # effects. When the method's RBS signature carries
           # `rigor:v1:predicate-if-true` / `predicate-if-false`
           # annotations, apply them to narrow the corresponding
-          # local-variable arguments on each edge.
+          # local-variable arguments on each edge. v0.1.1 Track
+          # 1 slice 3 — implicit-self calls (`recv == nil`,
+          # e.g. `admin?` inside an instance method body) flow
+          # through here too so `self`-targeted facts can edit
+          # `scope.self_type`.
           analyse_rbs_extended_contribution(node, scope)
         end
 
+        # v0.1.1 Track 1 slice 4 — `String#start_with?` /
+        # `#end_with?` / `#include?` against a `Constant<String>`
+        # needle attaches a relational `FactStore::Fact` to the
+        # local on each edge. The receiver's type does NOT
+        # change — Rigor has no "starts-with-X" carrier today —
+        # so the fact carries the predicate semantics for any
+        # downstream consumer that wants to read it (e.g. a
+        # plugin's `prepare(services)` hook in v0.1.x).
+        # Truthy edge: positive polarity. Falsey edge: negative
+        # polarity. Mirrors the equality-predicate fact pattern
+        # already used by `analyse_equality_predicate`.
+        STRING_PREDICATE_NAMES = %i[start_with? end_with? include?].freeze
+        private_constant :STRING_PREDICATE_NAMES
+
+        def analyse_string_predicate(node, scope)
+          return nil unless string_predicate_call?(node)
+
+          needle = string_predicate_needle(node, scope)
+          return nil if needle.nil?
+
+          local_name = node.receiver.name
+          return nil if scope.local(local_name).nil?
+
+          [
+            scope.with_fact(string_predicate_fact(local_name, node.name, needle, polarity: :positive)),
+            scope.with_fact(string_predicate_fact(local_name, node.name, needle, polarity: :negative))
+          ]
+        end
+
+        def string_predicate_call?(node)
+          STRING_PREDICATE_NAMES.include?(node.name) &&
+            node.receiver.is_a?(Prism::LocalVariableReadNode) &&
+            !node.arguments.nil? &&
+            node.arguments.arguments.size == 1
+        end
+
+        def string_predicate_needle(node, scope)
+          needle_type = static_literal_type(node.arguments.arguments.first, scope)
+          return nil unless needle_type.is_a?(Type::Constant) && needle_type.value.is_a?(String)
+
+          needle_type.value
+        end
+
+        def string_predicate_fact(name, predicate, needle, polarity:)
+          Analysis::FactStore::Fact.new(
+            bucket: :relational,
+            target: Analysis::FactStore::Target.local(name),
+            predicate: predicate,
+            payload: needle,
+            polarity: polarity,
+            stability: :local_binding
+          )
+        end
+
         ZERO_CLASS_PREDICATES = %i[positive? negative? zero? nonzero?].freeze
         COMPARISON_OPERATORS = %i[< <= > >=].freeze
         private_constant :ZERO_CLASS_PREDICATES, :COMPARISON_OPERATORS
@@ -1267,6 +1362,7 @@ module Rigor
 
         def apply_fact_to_scope(fact, call_node, entry_scope, target_scope, method_def)
           target_node = fact_target_node(fact, call_node, method_def)
+          return apply_self_fact(fact, target_node, entry_scope, target_scope) if fact.target_kind == :self
           return target_scope unless target_node.is_a?(Prism::LocalVariableReadNode)
 
           local_name = target_node.name
@@ -1277,6 +1373,45 @@ module Rigor
           target_scope.with_local(local_name, narrowed)
         end
 
+        # v0.1.1 Track 1 slice 3 — `target_kind == :self` facts
+        # (`predicate-if-true self is T`, `predicate-if-false
+        # self is T`) narrow whichever scope binding is bound to
+        # the call's receiver. Four receiver shapes participate:
+        #
+        #   `recv.method?` where recv is...
+        #   - `LocalVariableReadNode`            -> narrow that local
+        #   - `InstanceVariableReadNode`         -> narrow that ivar
+        #   - `Prism::SelfNode` (explicit self)  -> narrow `self_type`
+        #   - nil (implicit self call inside a method body)
+        #                                        -> narrow `self_type`
+        #
+        # Other receiver shapes (method chains, expressions) have
+        # no scope binding to narrow against and fall through.
+        def apply_self_fact(fact, receiver_node, entry_scope, target_scope)
+          case receiver_node
+          when nil, Prism::SelfNode
+            current = entry_scope.self_type
+            return target_scope if current.nil?
+
+            narrowed = narrow_for_fact(current, fact, entry_scope.environment)
+            target_scope.with_self_type(narrowed)
+          when Prism::LocalVariableReadNode
+            current = entry_scope.local(receiver_node.name)
+            return target_scope if current.nil?
+
+            narrowed = narrow_for_fact(current, fact, entry_scope.environment)
+            target_scope.with_local(receiver_node.name, narrowed)
+          when Prism::InstanceVariableReadNode
+            current = entry_scope.ivar(receiver_node.name)
+            return target_scope if current.nil?
+
+            narrowed = narrow_for_fact(current, fact, entry_scope.environment)
+            target_scope.with_ivar(receiver_node.name, narrowed)
+          else
+            target_scope
+          end
+        end
+
         # Resolves a Fact's target node. Mirrors the earlier
         # `effect_target_node` helper but reads from the
         # canonical Fact carrier; `:self` routes to the call
@@ -1291,7 +1426,9 @@ module Rigor
         end
 
         def resolve_rbs_extended_method(node, scope)
-          receiver_type = scope.type_of(node.receiver)
+          receiver_type = receiver_type_for_resolve(node, scope)
+          return nil if receiver_type.nil?
+
           class_name = rbs_extended_class_name(receiver_type)
           return nil if class_name.nil?
           return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
@@ -1305,6 +1442,13 @@ module Rigor
           nil
         end
 
+        # Implicit self call (`admin?` with no receiver inside an
+        # instance method body) — read the method definition from
+        # `scope.self_type` per v0.1.1 Track 1 slice 3.
+        def receiver_type_for_resolve(node, scope)
+          node.receiver.nil? ? scope.self_type : scope.type_of(node.receiver)
+        end
+
         def rbs_extended_class_name(receiver_type)
           case receiver_type
           when Type::Nominal, Type::Singleton then receiver_type.class_name