rigortype 0.0.1

data/lib/rigor/inference/fallback.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    FALLBACK_FAMILIES = %i[prism virtual].freeze
+    private_constant :FALLBACK_FAMILIES
+
+    # Immutable value object recorded by the typer whenever Scope#type_of
+    # falls back to Dynamic[Top] for a node it does not yet recognise. The
+    # contract for emitting these events lives in
+    # docs/internal-spec/inference-engine.md (Fail-Soft Policy).
+    #
+    # Fields:
+    # - node_class: the Ruby class of the node that triggered the
+    #   fallback (e.g. Prism::CallNode, or a Rigor::AST::Node subclass).
+    # - location: the Prism source location for real Prism nodes, or
+    #   nil for synthetic nodes.
+    # - family: :prism for real Prism nodes, :virtual for nodes
+    #   that include Rigor::AST::Node.
+    # - inner_type: the Rigor::Type returned to the caller (currently
+    #   always Dynamic[Top]; later slices may carry richer fallback
+    #   types).
+    Fallback = Data.define(:node_class, :location, :family, :inner_type) do
+      def initialize(node_class:, location:, family:, inner_type:)
+        raise ArgumentError, "node_class must be a Class, got #{node_class.class}" unless node_class.is_a?(Class)
+
+        unless FALLBACK_FAMILIES.include?(family)
+          raise ArgumentError, "family must be one of #{FALLBACK_FAMILIES.inspect}, got #{family.inspect}"
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rigor/inference/fallback_tracer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "fallback"
+
+module Rigor
+  module Inference
+    # Mutable observer that accumulates Rigor::Inference::Fallback events
+    # emitted by the type-inference engine. Pass an instance to
+    # Rigor::Scope#type_of(node, tracer: ...) to record every fail-soft
+    # fallback. The tracer MUST NOT change the return value of type_of;
+    # see docs/internal-spec/inference-engine.md (Fail-Soft Policy).
+    #
+    # Future slices may add additional record_* methods (e.g.
+    # record_dispatch_miss for Slice 3, record_budget_cutoff for Slice 5);
+    # the namespaced method names exist so a single tracer can collect
+    # multiple event families without confusing them.
+    class FallbackTracer
+      def initialize
+        @events = []
+      end
+
+      def events
+        @events.dup.freeze
+      end
+
+      def record_fallback(event)
+        raise ArgumentError, "expected Rigor::Inference::Fallback, got #{event.class}" unless event.is_a?(Fallback)
+
+        @events << event
+        self
+      end
+
+      def empty?
+        @events.empty?
+      end
+
+      def size
+        @events.size
+      end
+
+      def each(&block)
+        return @events.each unless block
+
+        @events.each(&block)
+        self
+      end
+
+      include Enumerable
+
+      def kinds
+        @events.map(&:node_class).uniq
+      end
+
+      def families
+        @events.map(&:family).uniq
+      end
+
+      def clear
+        @events.clear
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Slice 2 rule book that folds binary operations on `Rigor::Type::Constant`
+      # receivers into another `Constant` whenever:
+      #
+      # * the receiver is a recognised scalar literal,
+      # * exactly one argument is supplied and it is also a `Constant`,
+      # * the method name is in the curated whitelist for the receiver's class,
+      # * the operation cannot accidentally explode the analyzer (we cap
+      #   string-fold output at `STRING_FOLD_BYTE_LIMIT` bytes), and
+      # * the actual Ruby invocation does not raise.
+      #
+      # Anything else returns `nil`, signalling "no rule matched" so the
+      # caller (`ExpressionTyper`) falls back to `Dynamic[Top]` and records a
+      # fail-soft event. Slice 4 (RBS-backed) layers another dispatch tier
+      # behind this rule book, but the constant-folding semantics defined
+      # here MUST NOT regress: any value reachable by literal arithmetic at
+      # parse time is meant to be foldable independent of RBS data.
+      module ConstantFolding
+        module_function
+
+        NUMERIC_BINARY = Set[:+, :-, :*, :/, :%, :<, :<=, :>, :>=, :==, :!=, :<=>].freeze
+        STRING_BINARY  = Set[:+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>].freeze
+        SYMBOL_BINARY  = Set[:==, :!=, :<=>, :<, :<=, :>, :>=].freeze
+        BOOL_BINARY    = Set[:&, :|, :^, :==, :!=].freeze
+        NIL_BINARY     = Set[:==, :!=].freeze
+
+        STRING_FOLD_BYTE_LIMIT = 4096
+
+        # @return [Rigor::Type::Constant, nil]
+        def try_fold(receiver:, method_name:, args:)
+          return nil unless receiver.is_a?(Type::Constant)
+          return nil if args.size != 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant)
+          return nil unless safe?(receiver.value, method_name, arg.value)
+
+          Type::Combinator.constant_of(receiver.value.public_send(method_name, arg.value))
+        rescue StandardError
+          nil
+        end
+
+        def safe?(receiver_value, method_name, arg_value)
+          ops = ops_for(receiver_value)
+          return false unless ops.include?(method_name)
+          return false if integer_division_by_zero?(receiver_value, method_name, arg_value)
+          return false if string_blow_up?(receiver_value, method_name, arg_value)
+
+          true
+        end
+
+        def ops_for(receiver_value)
+          case receiver_value
+          when Integer, Float then NUMERIC_BINARY
+          when String         then STRING_BINARY
+          when Symbol         then SYMBOL_BINARY
+          when true, false    then BOOL_BINARY
+          when nil            then NIL_BINARY
+          else                     Set.new
+          end
+        end
+
+        # Integer / 0 and Integer % 0 raise; Float / 0 and Float / 0.0 return
+        # Float::INFINITY or NaN, which are valid `Constant[Float]` values.
+        def integer_division_by_zero?(receiver_value, method_name, arg_value)
+          return false unless %i[/ %].include?(method_name)
+          return false unless receiver_value.is_a?(Integer)
+
+          arg_value.is_a?(Integer) && arg_value.zero?
+        end
+
+        def string_blow_up?(receiver_value, method_name, arg_value)
+          return false unless receiver_value.is_a?(String)
+
+          case method_name
+          when :+ then string_concat_blow_up?(receiver_value, arg_value)
+          when :* then string_repeat_blow_up?(receiver_value, arg_value)
+          else false
+          end
+        end
+
+        def string_concat_blow_up?(receiver_value, arg_value)
+          arg_value.is_a?(String) &&
+            receiver_value.bytesize + arg_value.bytesize > STRING_FOLD_BYTE_LIMIT
+        end
+
+        def string_repeat_blow_up?(receiver_value, arg_value)
+          return false unless arg_value.is_a?(Integer)
+          return true if arg_value.negative?
+
+          receiver_value.bytesize * arg_value > STRING_FOLD_BYTE_LIMIT
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "../acceptance"
+require_relative "../rbs_type_translator"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Picks the RBS overload that should answer a call given the
+      # caller's actual argument types. Slice 4 phase 2c shape:
+      #
+      # 1. Filter overloads by positional arity (required, optional and
+      #    rest_positionals are honored; required_keywords disqualify the
+      #    overload because we do not yet thread keyword args through
+      #    `call_arg_types`).
+      # 2. Within the arity-matching overloads, accept the first one
+      #    whose every (param, arg) pair returns a `yes` or `maybe`
+      #    answer from `Rigor::Type#accepts(arg, mode: :gradual)`.
+      # 3. If no overload matches, fall back to `method_types.first`
+      #    so existing call sites keep their phase 1 / 2b behavior.
+      #    This preserves the fail-soft invariant of the dispatcher.
+      #
+      # The selector is intentionally agnostic about the dispatch kind
+      # (instance vs singleton). Both kinds share the same arity and
+      # acceptance shape; the difference is only in which `Definition`
+      # the caller fetched.
+      module OverloadSelector
+        module_function
+
+        # @param method_definition [RBS::Definition::Method]
+        # @param arg_types [Array<Rigor::Type>] caller-provided types in
+        #   positional order. Empty when there are no arguments.
+        # @param self_type [Rigor::Type] substitute for `Bases::Self`.
+        # @param instance_type [Rigor::Type] substitute for `Bases::Instance`.
+        # @param type_vars [Hash{Symbol => Rigor::Type}] substitution map
+        #   for class-level type variables (Slice 4 phase 2d). The
+        #   selector threads it through to {RbsTypeTranslator} so
+        #   parameter types like `::Array[Elem]` substitute Elem before
+        #   the accepts check, instead of degrading the param to
+        #   `Array[Dynamic[Top]]`.
+        # @param block_required [Boolean] when `true`, only overloads
+        #   that declare a block clause are considered (Slice 6 phase C
+        #   sub-phase 1). The fallback also prefers a block-bearing
+        #   overload over `method_types.first`. When `false` (the
+        #   Slice 4 phase 2c default) the selector behaves exactly as
+        #   before: `find` over arity-compatible overloads, falling
+        #   back to the first declaration.
+        # @return [RBS::MethodType, nil] the chosen overload, or nil
+        #   when the definition has no method types at all.
+        # rubocop:disable Metrics/ParameterLists
+        def select(method_definition, arg_types:, self_type:, instance_type:, type_vars: {}, block_required: false)
+          overloads = method_definition.method_types
+          return nil if overloads.empty?
+
+          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
+          )
+          return match if match
+          return overloads.find { |mt| overload_has_block?(mt) } if block_required
+
+          overloads.first
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        def overload_has_block?(method_type)
+          method_type.respond_to?(:block) && method_type.block
+        end
+
+        class << self
+          private
+
+          # rubocop:disable Metrics/ParameterLists
+          def find_matching_overload(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:)
+            overloads.find do |method_type|
+              next false if block_required && !OverloadSelector.overload_has_block?(method_type)
+
+              matches?(
+                method_type,
+                arg_types,
+                self_type: self_type,
+                instance_type: instance_type,
+                type_vars: type_vars
+              )
+            end
+          end
+          # rubocop:enable Metrics/ParameterLists
+
+          def matches?(method_type, arg_types, self_type:, instance_type:, type_vars:)
+            return false if method_type.respond_to?(:type_params) && rejects_keyword_required?(method_type)
+
+            fun = method_type.type
+            return false unless arity_compatible?(fun, arg_types.size)
+
+            params = positional_params_for(fun, arg_types.size)
+            params.zip(arg_types).all? do |param, arg|
+              accepts_param?(
+                param,
+                arg,
+                self_type: self_type,
+                instance_type: instance_type,
+                type_vars: type_vars
+              )
+            end
+          end
+
+          # Slice 4 phase 2c does not pass keyword arguments through the
+          # call site (caller passes only positional `arg_types`). An
+          # overload that requires keywords is therefore not a viable
+          # candidate; we skip it instead of forcing a fallback.
+          def rejects_keyword_required?(method_type)
+            fun = method_type.type
+            return false unless fun.respond_to?(:required_keywords)
+
+            !fun.required_keywords.empty?
+          end
+
+          def arity_compatible?(fun, actual_count)
+            min_arity = fun.required_positionals.size + fun.trailing_positionals.size
+            return false if actual_count < min_arity
+
+            return true if fun.rest_positionals
+
+            max_arity = min_arity + fun.optional_positionals.size
+            actual_count <= max_arity
+          end
+
+          # Builds the list of formal parameter declarations to compare
+          # against the actual arguments, in positional order: required
+          # first, then as many optionals as needed, then trailing
+          # required. Rest_positionals consumes the remainder; we
+          # repeat its single declaration for each absorbed argument.
+          def positional_params_for(fun, actual_count)
+            required = fun.required_positionals
+            optional = fun.optional_positionals
+            rest = fun.rest_positionals
+            trailing = fun.trailing_positionals
+
+            head = required.dup
+            optional_needed = [actual_count - head.size - trailing.size, 0].max
+            head.concat(optional.first(optional_needed))
+
+            absorbed_by_rest = actual_count - head.size - trailing.size
+            head.concat([rest] * absorbed_by_rest) if rest && absorbed_by_rest.positive?
+
+            head.concat(trailing)
+            head
+          end
+
+          def accepts_param?(param, arg, self_type:, instance_type:, type_vars:)
+            param_type = RbsTypeTranslator.translate(
+              param.type,
+              self_type: self_type,
+              instance_type: instance_type,
+              type_vars: type_vars
+            )
+            result = param_type.accepts(arg, mode: :gradual)
+            result.yes? || result.maybe?
+          end
+        end
+      end
+    end
+  end
+end