rigortype 0.1.16 → 0.1.18

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../type"
+require_relative "singleton_folding"
 
 module Rigor
   module Inference
@@ -32,7 +33,10 @@ module Rigor
 
         # @return [Array<Rigor::Type>, nil] block-param types, or
         #   nil to fall through to the next tier.
-        def block_param_types(receiver:, method_name:, args:)
+        def block_param_types(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
           case method_name
           when :times then times_block_params(receiver)
           when :upto  then upto_block_params(receiver, args.first)
@@ -66,7 +70,7 @@ module Rigor
         end
 
         def class_metaclass_receiver?(type)
-          type.is_a?(Type::Singleton) && type.class_name == "Class"
+          SingletonFolding.receiver?(type, "Class")
         end
 
         def times_block_params(receiver)

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

@@ -53,7 +53,10 @@ module Rigor
         INTEGER_REFINEMENT_PREDICATES = Set[:decimal_int, :numeric].freeze
         private_constant :INTEGER_REFINEMENT_PREDICATES
 
-        def try_dispatch(receiver:, method_name:, args:)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
           return nil if receiver.nil?
           return try_array(args) if method_name == :Array
           return try_numeric_constructor(method_name, args) if NUMERIC_CONSTRUCTORS.key?(method_name)

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

@@ -80,7 +80,10 @@ module Rigor
                          :LITERAL_PRESERVING_METHODS, :NON_EMPTY_LITERAL_PRESERVING_METHODS,
                          :WIDTH_PADDING_METHODS
 
-        def try_dispatch(receiver:, method_name:, args:, **)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
           return fold_array_join(receiver, args) if method_name == :join
           return fold_format(args) if FORMAT_METHODS.include?(method_name)
           return nil unless Type::Combinator.literal_string_compatible?(receiver)

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../type"
+require_relative "singleton_folding"
 
 module Rigor
   module Inference
@@ -57,8 +58,11 @@ module Rigor
         module_function
 
         # @return [Rigor::Type, nil] folded result, or nil to defer.
-        def try_dispatch(receiver:, method_name:, args:)
-          return nil unless dispatch_target?(receiver)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
+          return nil unless SingletonFolding.receiver?(receiver, "Math")
 
           # `log` is variadic (1 or 2 args), so it cannot live in the
           # fixed-arity sets above.
@@ -70,10 +74,6 @@ module Rigor
           nil
         end
 
-        def dispatch_target?(receiver)
-          receiver.is_a?(Type::Singleton) && receiver.class_name == "Math"
-        end
-
         # Unwraps a numeric `Constant` argument to its Ruby value.
         # Returns nil for any non-`Constant` or non-`Numeric` carrier.
         def numeric_constant(arg)

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

@@ -51,7 +51,10 @@ module Rigor
         # @param args [Array<Rigor::Type>] caller's argument
         #   types in order. Only the single-argument case
         #   matches; other arities decline.
-        def try_forward(receiver:, method_name:, args:)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
           return nil unless method_name == :method
           return nil if args.size != 1
 
@@ -72,7 +75,9 @@ module Rigor
         # well-defined type (the gradual-safety net mirrors
         # the engine's "BoundMethod erases to `Method`,
         # `Method#call: (*untyped) -> untyped`" RBS fallback).
-        def try_backward(receiver:, method_name:, args:, block_type:, environment:, call_node:, scope:)
+        def try_backward(context)
+          receiver = context.receiver
+          method_name = context.method_name
           return nil unless receiver.is_a?(Type::BoundMethod)
           return nil unless backward_method?(method_name)
 
@@ -94,11 +99,11 @@ module Rigor
           MethodDispatcher.dispatch(
             receiver_type: receiver.receiver_type,
             method_name: receiver.method_name,
-            arg_types: args,
-            block_type: block_type,
-            environment: environment,
-            call_node: call_node,
-            scope: scope
+            arg_types: context.args,
+            block_type: context.block_type,
+            environment: context.environment,
+            call_node: context.call_node,
+            scope: context.scope
           ) || Type::Combinator.untyped
         end
         # `Method#call` / `Method#()` and `Method#[]` are the

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

@@ -32,7 +32,16 @@ module Rigor
       #    matches, accept the first arity-and-gradual-accept match
       #    (the v0.1.1 behaviour). Alias / Interface / Intersection
       #    params still reach this pass, so call sites whose only
-      #    candidate IS an alias-typed overload keep working.
+      #    candidate IS an alias-typed overload keep working. One
+      #    exclusion: an `untyped` argument does NOT gradually match
+      #    a value-pinning param (`nil` / literal types — carriers
+      #    that admit only specific values). Those overloads carry
+      #    value-precise returns (`Kernel#Array: (nil) -> []`,
+      #    `Regexp#=~: (nil) -> nil`) that would otherwise win purely
+      #    by list position and inject false constants into the flow;
+      #    they remain selectable when the argument PROVES the value
+      #    (strict pass) or when no other overload matches (step 4's
+      #    fallback picks the first overload regardless).
       # 4. If no overload matches at all, fall back to
       #    `method_types.first` so existing call sites keep their
       #    phase 1 / 2b behavior. This preserves the fail-soft
@@ -393,9 +402,32 @@ module Rigor
               instance_type: instance_type,
               type_vars: type_vars
             )
+            # An `untyped` arg gradually accepts against every param,
+            # so a value-pinning param would be "matched" with zero
+            # evidence and its value-precise return (`(nil) -> []`)
+            # would beat broader overloads purely by list position.
+            # Decline the pair; only the strict pass (where the arg
+            # proves the value) or the final first-overload fallback
+            # may select such an overload. (Pass 1 already skips
+            # untyped args entirely, so this only engages pass 2.)
+            return false if untyped_arg?(arg) && value_pinning?(param_type)
+
             result = param_type.accepts(arg, mode: :gradual)
             result.yes? || result.maybe?
           end
+
+          # A type that admits only specific VALUES rather than a
+          # class of values: a `Constant` carrier (RBS `nil` and
+          # literal types both translate to one) or a union made up
+          # entirely of them (`true | false`, `1 | 2`, `nil?`-style
+          # optionals of literals).
+          def value_pinning?(type)
+            case type
+            when Type::Constant then true
+            when Type::Union then type.members.all? { |member| value_pinning?(member) }
+            else false
+            end
+          end
         end
       end
     end

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

@@ -118,20 +118,20 @@ module Rigor
         #   `Dynamic[Top]`, which is the false-positive-safe default
         #   for the open hierarchies (`< ActionController::Base`, …)
         #   the allow-list deliberately excludes.
-        def try_dispatch(receiver:, method_name:, args:, environment:, block_type: nil, self_type_override: nil, # rubocop:disable Metrics/ParameterLists
-                         public_only: false, scope: nil)
+        def try_dispatch(context)
+          environment = context.environment
           return nil if environment.nil?
           return nil unless environment.rbs_loader
 
           dispatch_for(
-            receiver: receiver,
-            method_name: method_name,
-            args: args,
+            receiver: context.receiver,
+            method_name: context.method_name,
+            args: context.args,
             environment: environment,
-            block_type: block_type,
-            self_type_override: self_type_override,
-            public_only: public_only,
-            scope: scope
+            block_type: context.block_type,
+            self_type_override: context.self_type_override,
+            public_only: context.public_only,
+            scope: context.scope
           )
         end
 
@@ -157,14 +157,15 @@ module Rigor
         # block" from "the block is untyped"; the binder treats both
         # the same way (every parameter defaults to `Dynamic[Top]`).
         # @return [Array<Rigor::Type>] positional block parameter types.
-        def block_param_types(receiver:, method_name:, args:, environment:)
+        def block_param_types(context)
+          environment = context.environment
           return [] if environment.nil?
           return [] unless environment.rbs_loader
 
           probe_block_param_types(
-            receiver: receiver,
-            method_name: method_name,
-            args: args,
+            receiver: context.receiver,
+            method_name: context.method_name,
+            args: context.args,
             environment: environment
           )
         end
@@ -248,6 +249,15 @@ module Rigor
               ["Array", :instance, tuple_type_args(receiver)]
             when Type::HashShape
               ["Hash", :instance, hash_shape_type_args(receiver)]
+            when Type::DataInstance
+              # ADR-48 — project a member-instance carrier to its tagging
+              # class (or the `Data` supertype) so non-member calls
+              # (`inspect`, `==`, `frozen?`, ...) resolve through RBS
+              # rather than mis-firing undefined-method. Member reads were
+              # already folded by DataFolding above this tier.
+              [receiver.class_name || "Data", :instance, []]
+            when Type::DataClass
+              [receiver.class_name || "Data", :singleton, []]
             when Type::BoundMethod
               # `BoundMethod` is a precision-bearing alias for
               # `Nominal[Method]`: it carries the

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../type"
+require_relative "singleton_folding"
 
 module Rigor
   module Inference
@@ -30,26 +31,25 @@ module Rigor
         module_function
 
         # @return [Rigor::Type, nil] folded result, or nil to defer.
-        def try_dispatch(receiver:, method_name:, args:)
-          return nil unless dispatch_target?(receiver)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
+          return nil unless SingletonFolding.receiver?(receiver, "Regexp")
           return fold_escape(args) if REGEXP_ESCAPE_METHODS.include?(method_name)
           return fold_new(args) if method_name == :new
 
           nil
         end
 
-        def dispatch_target?(receiver)
-          receiver.is_a?(Type::Singleton) && receiver.class_name == "Regexp"
-        end
-
         # `Regexp.escape(str)` / `.quote(str)` — one String arg.
         def fold_escape(args)
           return nil unless args.size == 1
 
-          arg = args.first
-          return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+          str = SingletonFolding.constant_string(args.first)
+          return nil if str.nil?
 
-          Type::Combinator.constant_of(Regexp.escape(arg.value))
+          Type::Combinator.constant_of(Regexp.escape(str))
         end
 
         # `Regexp.new(pattern)` / `Regexp.new(pattern, opts)` — constructs

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../type"
+require_relative "singleton_folding"
 
 module Rigor
   module Inference
@@ -30,8 +31,11 @@ module Rigor
         module_function
 
         # @return [Rigor::Type, nil] folded result, or nil to defer.
-        def try_dispatch(receiver:, method_name:, args:)
-          return nil unless dispatch_target?(receiver)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
+          return nil unless SingletonFolding.receiver?(receiver, "Set")
 
           case method_name
           when :[] then fold_bracket(args)
@@ -39,10 +43,6 @@ module Rigor
           end
         end
 
-        def dispatch_target?(receiver)
-          receiver.is_a?(Type::Singleton) && receiver.class_name == "Set"
-        end
-
         # `Set["a", "b", "c"]` — all positional args must be Constant.
         def fold_bracket(args)
           values = args.map do |a|

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../type"
+require_relative "call_context"
 
 module Rigor
   module Inference
@@ -91,7 +92,13 @@ module Rigor
           values_at: :tuple_values_at,
           :+ => :tuple_concat,
           compact: :tuple_compact,
-          take: :tuple_take
+          take: :tuple_take,
+          drop: :tuple_drop,
+          rotate: :tuple_rotate,
+          uniq: :tuple_uniq,
+          index: :tuple_find_index,
+          find_index: :tuple_find_index,
+          rindex: :tuple_rindex
         }.freeze
 
         HASH_SHAPE_HANDLERS = {
@@ -122,6 +129,7 @@ module Rigor
           values_at: :hash_values_at,
           fetch_values: :hash_fetch_values,
           assoc: :hash_assoc,
+          rassoc: :hash_rassoc,
           key: :hash_key,
           has_key?: :hash_has_key?,
           key?: :hash_has_key?,
@@ -167,7 +175,10 @@ module Rigor
         }.freeze
         private_constant :TO_S_BASE_REFINEMENTS
 
-        def try_dispatch(receiver:, method_name:, args:)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
           args ||= []
           handler = RECEIVER_HANDLERS[receiver.class]
           return nil unless handler
@@ -545,7 +556,9 @@ module Rigor
           # 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)
+              ShapeDispatch.try_dispatch(
+                CallContext.build(receiver: member, method_name: method_name, args: args)
+              )
             end
 
             case results.size
@@ -580,6 +593,10 @@ module Rigor
             Type::Combinator.integer_range(min, max)
           end
 
+          # `first` (no arg) → the first element (or `Constant[nil]` when
+          # empty). The `first(n)` arg-form is deliberately left to RBS
+          # overload selection (see the overload-selection specs) — folding
+          # it here would change that documented `Array[Elem]` contract.
           def tuple_first(tuple, _method_name, args)
             return nil unless args.empty?
             return Type::Combinator.constant_of(nil) if tuple.elements.empty?
@@ -832,21 +849,95 @@ module Rigor
             Type::Combinator.tuple_of(*kept)
           end
 
+          # `uniq` (no block) → `Tuple` of the first occurrence of each
+          # distinct value. Folds only when every element is a `Constant`
+          # so value equality is decidable; the block form defers.
+          def tuple_uniq(tuple, _method_name, args)
+            return nil unless args.empty?
+            return nil unless tuple.elements.all?(Type::Constant)
+
+            seen = []
+            kept = tuple.elements.each_with_object([]) do |element, acc|
+              next if seen.include?(element.value)
+
+              seen << element.value
+              acc << element
+            end
+            Type::Combinator.tuple_of(*kept)
+          end
+
+          # `index(obj)` / `find_index(obj)` → `Constant[Integer]` of the
+          # first element equal to `obj`, `Constant[nil]` when none match.
+          # Folds only for the argument form (the block form defers) when
+          # every element AND the argument are `Constant` (decidable
+          # equality).
+          def tuple_find_index(tuple, _method_name, args)
+            constant_index(tuple, args) { |elements, value| elements.index { |e| e.value == value } }
+          end
+
+          # `rindex(obj)` → the LAST matching index, same decidability gate.
+          def tuple_rindex(tuple, _method_name, args)
+            constant_index(tuple, args) { |elements, value| elements.rindex { |e| e.value == value } }
+          end
+
+          def constant_index(tuple, args)
+            return nil unless args.size == 1
+
+            needle = args.first
+            return nil unless needle.is_a?(Type::Constant)
+            return nil unless tuple.elements.all?(Type::Constant)
+
+            Type::Combinator.constant_of(yield(tuple.elements, needle.value))
+          end
+
           # `tuple.take(n)` — returns the first n elements as a
           # new Tuple. The argument must be a `Constant[Integer]`.
           # n <= 0 returns the empty Tuple; n >= size returns the
           # full receiver.
           def tuple_take(tuple, _method_name, args)
+            n = non_negative_count_arg(args)
+            return nil if n.nil?
+
+            Type::Combinator.tuple_of(*tuple.elements.take(n))
+          end
+
+          # `drop(n)` → `Tuple` of every element after the first `n`
+          # (mirror of `take`; `n >= size` → empty Tuple).
+          def tuple_drop(tuple, _method_name, args)
+            n = non_negative_count_arg(args)
+            return nil if n.nil?
+
+            Type::Combinator.tuple_of(*tuple.elements.drop(n))
+          end
+
+          # `rotate` (no arg → 1) / `rotate(n)` → `Tuple` of the elements
+          # cyclically shifted left by `n` (`Array#rotate` handles negative
+          # and out-of-range `n` by modulo, so any Integer arg folds).
+          def tuple_rotate(tuple, _method_name, args)
+            count =
+              if args.empty?
+                1
+              else
+                arg = args.size == 1 ? args.first : nil
+                return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Integer)
+
+                arg.value
+              end
+            Type::Combinator.tuple_of(*tuple.elements.rotate(count))
+          end
+
+          # Unwraps a single non-negative `Constant[Integer]` count argument
+          # (the `take` / `drop` / `first(n)` / `last(n)` shape). Returns the
+          # Integer, or nil to defer (wrong arity, non-constant, non-Integer,
+          # or negative — `Array#take`/`#drop` raise on negative counts).
+          def non_negative_count_arg(args)
             return nil unless args.size == 1
 
             arg = args.first
-            return nil unless arg.is_a?(Type::Constant)
-            return nil unless arg.value.is_a?(Integer)
-
-            n = arg.value
-            return Type::Combinator.tuple_of if n <= 0
+            return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Integer)
+            return nil if arg.value.negative?
 
-            Type::Combinator.tuple_of(*tuple.elements.take(n))
+            arg.value
           end
 
           # Returns `true` / `false` if every element's truthiness
@@ -1083,6 +1174,26 @@ module Rigor
             Type::Combinator.tuple_of(Type::Combinator.constant_of(key), shape.pairs[key])
           end
 
+          # `shape.rassoc(value)` — reverse of `assoc`: returns
+          # `Tuple[Constant[k], V]` for the first key whose VALUE equals
+          # the argument, `Constant[nil]` when none match. Folds when every
+          # value is a `Constant` so equality is decidable (mirrors
+          # `hash_key`, which returns only the key).
+          def hash_rassoc(shape, _method_name, args)
+            return nil unless args.size == 1
+            return nil unless shape.closed?
+            return nil unless shape.optional_keys.empty?
+            return nil unless shape.pairs.values.all?(Type::Constant)
+
+            arg = args.first
+            return nil unless arg.is_a?(Type::Constant)
+
+            pair = shape.pairs.find { |_k, v| v.value == arg.value }
+            return Type::Combinator.constant_of(nil) if pair.nil?
+
+            Type::Combinator.tuple_of(Type::Combinator.constant_of(pair.first), pair.last)
+          end
+
           # `shape.key(value)` — reverse lookup. Folds when every
           # value is a `Constant` so equality is decidable: returns
           # `Constant[k]` for the first matching key, `Constant[nil]`

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

@@ -2,6 +2,7 @@
 
 require "shellwords"
 require_relative "../../type"
+require_relative "singleton_folding"
 
 module Rigor
   module Inference
@@ -64,8 +65,11 @@ module Rigor
         module_function
 
         # @return [Rigor::Type, nil] folded result, or nil to defer.
-        def try_dispatch(receiver:, method_name:, args:)
-          return nil unless dispatch_target?(receiver)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
+          return nil unless SingletonFolding.receiver?(receiver, "Shellwords")
           return nil unless SHELLWORDS_ALL_METHODS.include?(method_name)
 
           if SHELLWORDS_ESCAPE_METHODS.include?(method_name)
@@ -77,18 +81,14 @@ module Rigor
           end
         end
 
-        def dispatch_target?(receiver)
-          receiver.is_a?(Type::Singleton) && receiver.class_name == "Shellwords"
-        end
-
         # `Shellwords.escape(str)` / `.shellescape(str)` — one String arg.
         def fold_escape(args)
           return nil unless args.size == 1
 
-          arg = args.first
-          return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+          str = SingletonFolding.constant_string(args.first)
+          return nil if str.nil?
 
-          Type::Combinator.constant_of(Shellwords.escape(arg.value))
+          Type::Combinator.constant_of(Shellwords.escape(str))
         end
 
         # `Shellwords.split(line)` / `.shellsplit` / `.shellwords` —
@@ -96,10 +96,10 @@ module Rigor
         def fold_split(args)
           return nil unless args.size == 1
 
-          arg = args.first
-          return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+          str = SingletonFolding.constant_string(args.first)
+          return nil if str.nil?
 
-          tokens = Shellwords.split(arg.value)
+          tokens = Shellwords.split(str)
           return nil if tokens.size > SHELLWORDS_SPLIT_LIMIT
 
           Type::Combinator.tuple_of(*tokens.map { |t| Type::Combinator.constant_of(t) })

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Shared helpers for the per-singleton folding tiers (CGI, URI,
+      # Shellwords, Math, Time, Regexp, Set, File, …).
+      #
+      # Each of those tiers folds a pure module-/class-function call on
+      # `Constant` receivers, and every one of them opens with the same
+      # two questions:
+      #
+      #   1. "Is the receiver the `Singleton[X]` I handle?" — a one-line
+      #      `is_a?(Type::Singleton) && class_name == "X"` that used to be
+      #      copied verbatim into nine modules.
+      #   2. "Is this argument a foldable `Constant[String]`?" — the
+      #      `is_a?(Type::Constant) && value.is_a?(String)` unwrap the
+      #      string-folding tiers (CGI / URI / Shellwords / Regexp) gate
+      #      on before evaluating the literal.
+      #
+      # Centralising both here keeps the receiver-shape and
+      # constant-unwrap knowledge in one place: if `Type::Singleton` or
+      # `Type::Constant` ever changes shape, there is a single edit
+      # rather than nine. The per-tier fold bodies stay where they are —
+      # only the shared gate moves.
+      module SingletonFolding
+        module_function
+
+        # True when `receiver` is the class/module singleton named
+        # `class_name` (e.g. `Singleton[Math]`).
+        def receiver?(receiver, class_name)
+          receiver.is_a?(Type::Singleton) && receiver.class_name == class_name
+        end
+
+        # The `String` value carried by a `Constant[String]` argument, or
+        # `nil` for any other carrier. Callers fold when this is non-nil
+        # and decline (return nil, deferring to the RBS tier) otherwise.
+        def constant_string(arg)
+          return nil unless arg.is_a?(Type::Constant)
+
+          value = arg.value
+          value.is_a?(String) ? value : nil
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../type"
+require_relative "singleton_folding"
 
 module Rigor
   module Inference
@@ -33,8 +34,11 @@ module Rigor
         module_function
 
         # @return [Rigor::Type, nil] folded result, or nil to defer.
-        def try_dispatch(receiver:, method_name:, args:)
-          return nil unless dispatch_target?(receiver)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
+          return nil unless SingletonFolding.receiver?(receiver, "Time")
           return nil unless TIME_UTC_METHODS.include?(method_name)
           return nil unless args.size.between?(1, MAX_TIME_ARITY)
           return nil unless args.all?(Type::Constant)
@@ -46,10 +50,6 @@ module Rigor
         rescue StandardError
           nil
         end
-
-        def dispatch_target?(receiver)
-          receiver.is_a?(Type::Singleton) && receiver.class_name == "Time"
-        end
       end
     end
   end