rigortype 0.0.5 → 0.0.7

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

@@ -72,6 +72,19 @@ module Rigor
           size: :tuple_size,
           length: :tuple_size,
           count: :tuple_size,
+          empty?: :tuple_empty?,
+          any?: :tuple_any?,
+          all?: :tuple_all?,
+          none?: :tuple_none?,
+          include?: :tuple_include?,
+          sum: :tuple_sum,
+          min: :tuple_min,
+          max: :tuple_max,
+          sort: :tuple_sort,
+          reverse: :tuple_reverse,
+          to_a: :tuple_to_a,
+          to_h: :tuple_to_h,
+          zip: :tuple_zip,
           :[] => :tuple_index,
           fetch: :tuple_index,
           dig: :tuple_dig
@@ -80,6 +93,18 @@ module Rigor
         HASH_SHAPE_HANDLERS = {
           size: :hash_size,
           length: :hash_size,
+          count: :hash_size,
+          empty?: :hash_empty?,
+          any?: :hash_any?,
+          keys: :hash_keys,
+          values: :hash_values,
+          first: :hash_first,
+          flatten: :hash_flatten,
+          compact: :hash_compact,
+          to_a: :hash_to_a,
+          to_h: :hash_to_h,
+          invert: :hash_invert,
+          merge: :hash_merge,
           :[] => :hash_lookup,
           fetch: :hash_lookup,
           dig: :hash_dig,
@@ -369,6 +394,239 @@ module Rigor
             Type::Combinator.constant_of(tuple.elements.size)
           end
 
+          # `tuple.empty?` — folds to a precise bool from the
+          # tuple's known arity.
+          # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
+          def tuple_empty?(tuple, _method_name, args)
+            return nil unless args.empty?
+
+            Type::Combinator.constant_of(tuple.elements.empty?)
+          end
+
+          # `tuple.any?` (no-arg, no-block) — empty tuple → false,
+          # non-empty → true. The block / arg forms flow through
+          # `BlockFolding` and the RBS tier.
+          def tuple_any?(tuple, _method_name, args)
+            return nil unless args.empty?
+
+            Type::Combinator.constant_of(!tuple.elements.empty?)
+          end
+
+          # `tuple.all?` (no-arg, no-block) — true for empty
+          # tuple (vacuous truth) AND for non-empty tuples whose
+          # every element is provably truthy. Mixed / unknown
+          # element truthiness declines so the RBS / BlockFolding
+          # tiers can still answer.
+          def tuple_all?(tuple, _method_name, args)
+            return nil unless args.empty?
+            return Type::Combinator.constant_of(true) if tuple.elements.empty?
+
+            decision = tuple_predicate_truthiness(tuple, all: true)
+            return nil if decision.nil?
+
+            Type::Combinator.constant_of(decision)
+          end
+
+          # `tuple.none?` (no-arg, no-block) — true when every
+          # element is provably falsey, false when any element is
+          # provably truthy. Empty tuple folds to true (vacuous).
+          def tuple_none?(tuple, _method_name, args)
+            return nil unless args.empty?
+            return Type::Combinator.constant_of(true) if tuple.elements.empty?
+
+            decision = tuple_predicate_truthiness(tuple, all: false)
+            return nil if decision.nil?
+
+            Type::Combinator.constant_of(decision)
+          end
+
+          # `tuple.include?(needle)` — folds to a precise bool when
+          # the needle is a `Constant` and the tuple's elements
+          # are all `Constant` (so disjointness is checkable).
+          # If any element matches the needle's value the answer
+          # is `Constant[true]`; if every element is a Constant
+          # whose value is structurally distinct from the needle
+          # the answer is `Constant[false]`.
+          def tuple_include?(tuple, _method_name, args)
+            return nil unless args.size == 1
+
+            needle = args.first
+            return nil unless needle.is_a?(Type::Constant)
+            return Type::Combinator.constant_of(false) if tuple.elements.empty?
+
+            return Type::Combinator.constant_of(true) if any_element_matches?(tuple.elements, needle.value)
+            return Type::Combinator.constant_of(false) if tuple.elements.all?(Type::Constant)
+
+            nil
+          end
+          # rubocop:enable Style/ReturnNilInPredicateMethodDefinition
+
+          # `tuple.sum` — when every element is a numeric Constant,
+          # fold to `Constant[sum]`. Mixed / non-numeric elements
+          # decline so RBS widens.
+          def tuple_sum(tuple, _method_name, args)
+            return nil unless args.empty?
+            return Type::Combinator.constant_of(0) if tuple.elements.empty?
+
+            values = constant_numeric_values(tuple.elements)
+            return nil if values.nil?
+
+            Type::Combinator.constant_of(values.sum)
+          end
+
+          # `tuple.min` / `tuple.max` — fold when every element is
+          # a `Constant` whose values share a Ruby-comparable
+          # domain. Empty tuples fold to `Constant[nil]`.
+          def tuple_min(tuple, _method_name, args)
+            tuple_minmax(tuple, args, :min)
+          end
+
+          def tuple_max(tuple, _method_name, args)
+            tuple_minmax(tuple, args, :max)
+          end
+
+          def tuple_minmax(tuple, args, edge)
+            return nil unless args.empty?
+            return Type::Combinator.constant_of(nil) if tuple.elements.empty?
+
+            values = constant_values(tuple.elements)
+            return nil if values.nil?
+
+            result = values.public_send(edge)
+            Type::Combinator.constant_of(result)
+          rescue StandardError
+            nil
+          end
+
+          # `tuple.sort` — every element must be a `Constant` and
+          # the values must Ruby-compare. The result is a Tuple
+          # with the same elements in sorted order. Comparison
+          # failures (mixed-class incomparable values) decline.
+          def tuple_sort(tuple, _method_name, args)
+            return nil unless args.empty?
+            return tuple if tuple.elements.size <= 1
+
+            values = constant_values(tuple.elements)
+            return nil if values.nil?
+
+            sorted = values.sort
+            Type::Combinator.tuple_of(*sorted.map { |v| Type::Combinator.constant_of(v) })
+          rescue StandardError
+            nil
+          end
+
+          # `tuple.reverse` — independent of element shape; a
+          # tuple-precise reversed Tuple.
+          def tuple_reverse(tuple, _method_name, args)
+            return nil unless args.empty?
+
+            Type::Combinator.tuple_of(*tuple.elements.reverse)
+          end
+
+          # `tuple.to_a` — Tuple is structurally identical to its
+          # to_a (Ruby returns the receiver itself for an Array).
+          def tuple_to_a(tuple, _method_name, args)
+            return nil unless args.empty?
+
+            tuple
+          end
+
+          # `tuple.zip(other_1, other_2, …)` — pairs the receiver's
+          # per-position elements with the per-position elements of
+          # each other Tuple-shaped argument. The result is a Tuple
+          # of Tuples whose arity matches the receiver: position
+          # `i` is `Tuple[receiver[i], other_1[i], other_2[i], …]`.
+          # Out-of-range positions in any `other_k` contribute
+          # `Constant[nil]` (matching Ruby's runtime semantics).
+          # Declines when any `other_k` is not a Tuple, since the
+          # arity is then unknown and the result would be
+          # `Array[Array[…]]` — RBS already gives that answer.
+          def tuple_zip(tuple, _method_name, args)
+            return nil if args.empty? || args.size > MAX_ZIP_ARITY
+            return nil unless args.all?(Type::Tuple)
+
+            zipped = tuple.elements.each_with_index.map do |elem, i|
+              positions = [elem] + args.map { |other| other.elements[i] || Type::Combinator.constant_of(nil) }
+              Type::Combinator.tuple_of(*positions)
+            end
+            Type::Combinator.tuple_of(*zipped)
+          end
+
+          MAX_ZIP_ARITY = 8
+          private_constant :MAX_ZIP_ARITY
+
+          # `tuple.to_h` — folds when every Tuple element is itself
+          # a 2-element Tuple whose first element is a `Constant`
+          # (so it can serve as a Hash key). Produces a closed
+          # `HashShape` whose entries mirror the per-position
+          # pairs. Empty Tuples fold to the empty HashShape.
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def tuple_to_h(tuple, _method_name, args)
+            return nil unless args.empty?
+            return Type::Combinator.hash_shape_of({}) if tuple.elements.empty?
+
+            pairs = tuple.elements.map { |e| tuple_to_h_pair(e) }
+            return nil if pairs.any?(&:nil?)
+            return nil unless pairs.map(&:first).uniq.size == pairs.size
+
+            Type::Combinator.hash_shape_of(pairs.to_h)
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          def tuple_to_h_pair(element)
+            return nil unless element.is_a?(Type::Tuple)
+            return nil unless element.elements.size == 2
+
+            key = element.elements[0]
+            value = element.elements[1]
+            return nil unless key.is_a?(Type::Constant)
+
+            [key.value, value]
+          end
+
+          # Returns `true` / `false` if every element's truthiness
+          # agrees, nil for mixed-or-unknown shapes. `all: true`
+          # checks every element is truthy; `all: false` checks
+          # every element is falsey.
+          def tuple_predicate_truthiness(tuple, all:)
+            samples = tuple.elements.map { |e| element_truthiness(e) }
+            return nil if samples.any?(:unknown)
+
+            if all
+              samples.all?(:truthy)
+            else
+              samples.all?(:falsey)
+            end
+          end
+
+          def element_truthiness(type)
+            return :unknown unless type.is_a?(Type::Constant)
+
+            falsey = type.value.nil? || type.value == false
+            falsey ? :falsey : :truthy
+          end
+
+          def any_element_matches?(elements, value)
+            elements.any? { |e| e.is_a?(Type::Constant) && e.value == value }
+          end
+
+          # Per-element Constant value extraction. Returns nil
+          # when any element is non-Constant, so the caller can
+          # decline.
+          def constant_values(elements)
+            return nil unless elements.all?(Type::Constant)
+
+            elements.map(&:value)
+          end
+
+          def constant_numeric_values(elements)
+            values = constant_values(elements)
+            return nil if values.nil?
+            return nil unless values.all?(Numeric)
+
+            values
+          end
+
           # `tuple[i]`, `tuple[range]`, `tuple[start, length]`, and
           # `tuple.fetch(i)` for static arguments. Out-of-range single
           # indices still fall through because the same handler serves
@@ -463,6 +721,157 @@ module Rigor
             Type::Combinator.constant_of(shape.pairs.size)
           end
 
+          # `shape.empty?` — folds to a precise bool when the
+          # shape's emptiness is statically known. Closed shapes
+          # with no optional keys have a fixed size, so empty?
+          # is `Constant[shape.pairs.empty?]`. The handler returns
+          # `Type::t | nil` (nil signals "no rule, defer to next
+          # tier") so the standard predicate-return rubocop rule
+          # does not apply.
+          # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
+          def hash_empty?(shape, _method_name, args)
+            return nil unless args.empty?
+            return nil unless shape.closed?
+            return nil unless shape.optional_keys.empty?
+
+            Type::Combinator.constant_of(shape.pairs.empty?)
+          end
+
+          # `shape.any?` (no block, no arg) — opposite of
+          # `empty?`. The block / arg forms are answered by the
+          # RBS / BlockFolding tier.
+          def hash_any?(shape, _method_name, args)
+            return nil unless args.empty?
+            return nil unless shape.closed?
+            return nil unless shape.optional_keys.empty?
+
+            Type::Combinator.constant_of(!shape.pairs.empty?)
+          end
+          # rubocop:enable Style/ReturnNilInPredicateMethodDefinition
+
+          # `shape.keys` — returns a `Tuple[Constant<k>…]` for a
+          # closed shape with no optional keys; the Tuple's
+          # arity matches the shape's per-key declaration order
+          # so downstream `tuple[i]` projections stay precise.
+          def hash_keys(shape, _method_name, args)
+            return nil unless args.empty?
+            return nil unless shape.closed?
+            return nil unless shape.optional_keys.empty?
+
+            Type::Combinator.tuple_of(*shape.pairs.keys.map { |k| Type::Combinator.constant_of(k) })
+          end
+
+          # `shape.values` — returns a `Tuple[V_1, …, V_n]` for a
+          # closed shape with no optional keys, the Tuple's arity
+          # matching the shape's per-key value order.
+          def hash_values(shape, _method_name, args)
+            return nil unless args.empty?
+            return nil unless shape.closed?
+            return nil unless shape.optional_keys.empty?
+
+            Type::Combinator.tuple_of(*shape.pairs.values)
+          end
+
+          # `shape.to_a` — returns a per-entry `Tuple[Tuple[K, V], …]`
+          # for a closed shape with no optional keys.
+          def hash_to_a(shape, _method_name, args)
+            return nil unless args.empty?
+            return nil unless shape.closed?
+            return nil unless shape.optional_keys.empty?
+
+            entries = shape.pairs.map do |k, v|
+              Type::Combinator.tuple_of(Type::Combinator.constant_of(k), v)
+            end
+            Type::Combinator.tuple_of(*entries)
+          end
+
+          # `shape.to_h` — Hash is structurally identical to its
+          # to_h (Ruby returns the receiver itself for a Hash).
+          def hash_to_h(shape, _method_name, args)
+            return nil unless args.empty?
+
+            shape
+          end
+
+          # `shape.invert` — swaps keys and values. Folds when
+          # every value is a `Constant` whose value is a Symbol
+          # or String (the only hashable types that
+          # `HashShape` accepts as keys). Duplicate values would
+          # alias under inversion, so Rigor declines on
+          # collisions rather than silently dropping entries.
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def hash_invert(shape, _method_name, args)
+            return nil unless args.empty?
+            return nil unless shape.closed?
+            return nil unless shape.optional_keys.empty?
+            return nil unless shape.pairs.values.all?(Type::Constant)
+            return nil unless shape.pairs.values.all? { |v| v.value.is_a?(Symbol) || v.value.is_a?(String) }
+
+            inverted = shape.pairs.each_with_object({}) do |(k, v), acc|
+              return nil if acc.key?(v.value)
+
+              acc[v.value] = Type::Combinator.constant_of(k)
+            end
+            Type::Combinator.hash_shape_of(inverted)
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+          # `shape.first` — returns the first `[k, v]` pair as a
+          # 2-Tuple, or `Constant[nil]` when the shape is empty.
+          # Folds only on closed shapes with no optional keys
+          # (open shapes might contribute extra keys at runtime).
+          def hash_first(shape, _method_name, args)
+            return nil unless args.empty?
+            return nil unless shape.closed?
+            return nil unless shape.optional_keys.empty?
+            return Type::Combinator.constant_of(nil) if shape.pairs.empty?
+
+            key, value = shape.pairs.first
+            Type::Combinator.tuple_of(Type::Combinator.constant_of(key), value)
+          end
+
+          # `shape.flatten` — flattens to `[k_1, v_1, k_2, v_2, …]`
+          # at depth 1. Closed shapes only; element order matches
+          # the per-key declaration order.
+          def hash_flatten(shape, _method_name, args)
+            return nil unless args.empty?
+            return nil unless shape.closed?
+            return nil unless shape.optional_keys.empty?
+
+            elements = shape.pairs.flat_map { |k, v| [Type::Combinator.constant_of(k), v] }
+            Type::Combinator.tuple_of(*elements)
+          end
+
+          # `shape.compact` — drops every entry whose value is
+          # `Constant[nil]`. Folds only when every value is a
+          # `Constant` (so the drop set is decidable). Mixed-shape
+          # values decline so the RBS tier widens.
+          def hash_compact(shape, _method_name, args)
+            return nil unless args.empty?
+            return nil unless shape.closed?
+            return nil unless shape.optional_keys.empty?
+            return nil unless shape.pairs.values.all?(Type::Constant)
+
+            kept = shape.pairs.reject { |_k, v| v.value.nil? }
+            Type::Combinator.hash_shape_of(kept)
+          end
+
+          # `shape.merge(other)` — when both sides are closed
+          # HashShape with no optional keys, fold to the merged
+          # HashShape. Right-hand entries override left-hand
+          # entries on key collision (matching Ruby's runtime
+          # `Hash#merge`).
+          def hash_merge(shape, _method_name, args)
+            return nil unless args.size == 1
+            return nil unless shape.closed? && shape.optional_keys.empty?
+
+            other = args.first
+            return nil unless other.is_a?(Type::HashShape)
+            return nil unless other.closed? && other.optional_keys.empty?
+
+            Type::Combinator.hash_shape_of(shape.pairs.merge(other.pairs))
+          end
+
           # `shape[k]` and `shape.fetch(k)` for a static symbol/string
           # key. Missing-key resolution depends on the method:
           #

data/lib/rigor/inference/method_dispatcher.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require_relative "../reflection"
 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/block_folding"
 require_relative "method_dispatcher/file_folding"
 require_relative "method_dispatcher/kernel_dispatch"
 
@@ -40,7 +42,7 @@ module Rigor
     # The dispatcher's public signature reserves space for `block_type:`
     # and ADR-2 plugin extensions (later slices), so call sites added
     # now do not have to be rewritten when those tiers arrive.
-    module MethodDispatcher
+    module MethodDispatcher # rubocop:disable Metrics/ModuleLength
       module_function
 
       # @param receiver_type [Rigor::Type, nil] type of the receiver expression, or
@@ -59,7 +61,7 @@ module Rigor
       def dispatch(receiver_type:, method_name:, arg_types:, block_type: nil, environment: nil)
         return nil if receiver_type.nil?
 
-        precise = dispatch_precise_tiers(receiver_type, method_name, arg_types)
+        precise = dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type)
         return precise if precise
 
         rbs_result = RbsDispatch.try_dispatch(
@@ -83,19 +85,28 @@ module Rigor
       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)
+      # file-path fold, block 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.
+      #
+      # `BlockFolding` runs last among the precision tiers because
+      # its rules apply only to block-taking calls, so the cheaper
+      # arity-based fold tiers above it filter out the common
+      # cases first. When `block_type` is nil the tier is a no-op.
+      def dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type = nil)
+        meta_result = try_meta_introspection(receiver_type, method_name, arg_types)
         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) ||
-          KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types)
+          KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          BlockFolding.try_fold(
+            receiver: receiver_type, method_name: method_name, args: arg_types, block_type: block_type
+          )
       end
 
       def try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type)
@@ -114,16 +125,13 @@ module Rigor
       end
 
       def user_class_fallback_receiver(receiver_type, environment)
-        loader = environment.rbs_loader
-        return nil if loader.nil?
-
         case receiver_type
         when Type::Nominal
-          return nil if loader.class_known?(receiver_type.class_name)
+          return nil if Rigor::Reflection.rbs_class_known?(receiver_type.class_name, environment: environment)
 
           environment.nominal_for_name("Object")
         when Type::Singleton
-          return nil if loader.class_known?(receiver_type.class_name)
+          return nil if Rigor::Reflection.rbs_class_known?(receiver_type.class_name, environment: environment)
 
           environment.singleton_for_name("Class")
         end
@@ -141,10 +149,10 @@ module Rigor
       # adjacent calls and the trivial `instance_of?(self)`
       # later as the rule catalogue grows; for now only `class`
       # is handled.
-      def try_meta_introspection(receiver_type, method_name)
+      def try_meta_introspection(receiver_type, method_name, arg_types = [])
         case method_name
         when :class then meta_class(receiver_type)
-        when :new then meta_new(receiver_type)
+        when :new then meta_new(receiver_type, arg_types)
         end
       end
 
@@ -161,12 +169,74 @@ module Rigor
       # plumbing for user classes, so a discovered-class
       # `ScanAccumulator.new` types as `Nominal[ScanAccumulator]`
       # rather than `Class`.
-      def meta_new(receiver_type)
+      #
+      # v0.0.7 — for the curated set of immutable scalar-shaped
+      # classes that `Type::Constant::SCALAR_CLASSES` accepts
+      # (today: `Pathname`), `.new(Constant<…>)` lifts to a
+      # `Constant<…>` carrier so downstream method calls fold
+      # through the standard catalog tier.
+      def meta_new(receiver_type, arg_types = [])
         return nil unless receiver_type.is_a?(Type::Singleton)
 
+        constant_lift = constant_constructor_lift(receiver_type.class_name, arg_types)
+        return constant_lift if constant_lift
+
+        array_lift = array_new_lift(receiver_type.class_name, arg_types)
+        return array_lift if array_lift
+
         Type::Combinator.nominal_of(receiver_type.class_name)
       end
 
+      CONSTANT_CONSTRUCTORS = {
+        "Pathname" => ->(arg) { Pathname.new(arg) }
+      }.freeze
+      private_constant :CONSTANT_CONSTRUCTORS
+
+      def constant_constructor_lift(class_name, arg_types)
+        builder = CONSTANT_CONSTRUCTORS[class_name]
+        return nil if builder.nil?
+        return nil unless arg_types.size == 1
+
+        arg = arg_types.first
+        return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+
+        result = builder.call(arg.value)
+        Type::Combinator.constant_of(result)
+      rescue StandardError
+        nil
+      end
+
+      # `Array.new(n, value)` and `Array.new(n)` (no value, default
+      # `nil`) lift to a per-position `Tuple[…]` when `n` is a
+      # small `Constant<Integer>`. Cap at `ARRAY_NEW_TUPLE_LIMIT`
+      # (16) so a `Array.new(1_000_000)` does not balloon the
+      # carrier; oversize calls fall back to `Nominal[Array]`.
+      ARRAY_NEW_TUPLE_LIMIT = 16
+      private_constant :ARRAY_NEW_TUPLE_LIMIT
+
+      def array_new_lift(class_name, arg_types)
+        return nil unless class_name == "Array"
+        return nil if arg_types.empty? || arg_types.size > 2
+
+        size = array_new_size(arg_types.first)
+        return nil if size.nil? || size.negative? || size > ARRAY_NEW_TUPLE_LIMIT
+
+        fill = array_new_fill(arg_types[1])
+        Type::Combinator.tuple_of(*Array.new(size, fill))
+      end
+
+      def array_new_size(type)
+        return nil unless type.is_a?(Type::Constant) && type.value.is_a?(Integer)
+
+        type.value
+      end
+
+      def array_new_fill(type)
+        return Type::Combinator.constant_of(nil) if type.nil?
+
+        type
+      end
+
       CONSTANT_METACLASSES = {
         Integer => "Integer", Float => "Float", String => "String",
         Symbol => "Symbol", Range => "Range",

data/lib/rigor/inference/method_parameter_binder.rb

@@ -2,6 +2,7 @@
 
 require "prism"
 
+require_relative "../reflection"
 require_relative "../type"
 require_relative "../rbs_extended"
 require_relative "rbs_type_translator"
@@ -136,18 +137,15 @@ module Rigor
       def lookup_rbs_method(def_node)
         return nil if @class_path.nil?
 
-        loader = @environment.rbs_loader
-        return nil if loader.nil?
-
         method_name = def_node.name
         # `def self.foo` always means a singleton method on the
         # immediate enclosing class. `def foo` inside `class << self`
         # is also a singleton method (the StatementEvaluator threads
         # the `singleton:` flag through this case).
         if def_node.receiver.is_a?(Prism::SelfNode) || @singleton
-          loader.singleton_method(class_name: @class_path, method_name: method_name)
+          Rigor::Reflection.singleton_method_definition(@class_path, method_name, environment: @environment)
         else
-          loader.instance_method(class_name: @class_path, method_name: method_name)
+          Rigor::Reflection.instance_method_definition(@class_path, method_name, environment: @environment)
         end
       end