sorbet-runtime 0.5.6304 → 0.5.6322

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad7aaa626b9d7f8f480dac76029fed7bc8fd8febdeded0771c623f906d42e4f8
-  data.tar.gz: 7cb5dcafcc91e2926190212ced5deb346c422a97ebe7a88aecff480f42d5b41d
+  metadata.gz: e6c77d695c5b2ad896c9bf845303e742d41c07c24d55c4aedcfd8f6acb9580dc
+  data.tar.gz: 8cbbe5d304fb8f7742a5785232511c92eb68948490216202a7c6faf1fdf90bc1
 SHA512:
-  metadata.gz: b0afc55dc0d87167d30aeb37ab9f77bd0cd059f32a2a1f745f2900acbfa70d97b08c6fca8e75248e427e9038568ec6ed75a7bf09a29b674e7edfacc737ad47dc
-  data.tar.gz: 9e5fe04e4c333c59d4856b5136187e91b4cf91e671b450b1d1e4f9b0b7de2a97af9311087a0ebcfb0749c422828394a3e226c8867e4059624f1ee3023ffffaea
+  metadata.gz: aea4d354cc43e0797dd8e651f514f316508806b8d557248a31c5cf21ab651d8537788ad90f635634a684c1183e5066862e1bfef56748b9d722cd8edab8e0a3c3
+  data.tar.gz: 32f1bd879783697530fc548ce7fbf2477a7dc0458e6e3d7904f5f88c3c304f6f148029f2ab16afddc90993c8103bb80ad8d9afeaeb765a0cfe1c97606a864231

data/lib/types/configuration.rb

@@ -2,6 +2,9 @@
 # frozen_string_literal: true
 
 module T::Configuration
+  # Cache this comparisonn to avoid two allocations all over the place.
+  AT_LEAST_RUBY_2_7 = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7')
+
   # Announces to Sorbet that we are currently in a test environment, so it
   # should treat any sigs which are marked `.checked(:tests)` as if they were
   # just a normal sig.
@@ -395,7 +398,12 @@ module T::Configuration
   MODULE_NAME = Module.instance_method(:name)
   private_constant :MODULE_NAME
 
-  @default_module_name_mangler = ->(type) {MODULE_NAME.bind(type).call}
+  if T::Configuration::AT_LEAST_RUBY_2_7
+    @default_module_name_mangler = ->(type) {MODULE_NAME.bind_call(type)}
+  else
+    @default_module_name_mangler = ->(type) {MODULE_NAME.bind(type).call}
+  end
+
   @module_name_mangler = nil
 
   def self.module_name_mangler

data/lib/types/private/methods/_methods.rb

@@ -108,10 +108,7 @@ module T::Private::Methods
         # method_to_key(ancestor.instance_method(method_name)) is not (just) an optimization, but also required for
         # correctness, since ancestor.method_defined?(method_name) may return true even if method_name is not defined
         # directly on ancestor but instead an ancestor of ancestor.
-        if (ancestor.method_defined?(method_name) ||
-            ancestor.private_method_defined?(method_name) ||
-            ancestor.protected_method_defined?(method_name)) &&
-           final_method?(method_owner_and_name_to_key(ancestor, method_name))
+        if final_method?(method_owner_and_name_to_key(ancestor, method_name))
           definition_file, definition_line = T::Private::Methods.signature_for_method(ancestor.instance_method(method_name)).method.source_location
           is_redefined = target == ancestor
           caller_loc = caller_locations&.find {|l| !l.to_s.match?(%r{sorbet-runtime[^/]*/lib/}) }
@@ -220,6 +217,8 @@ module T::Private::Methods
       # make sure to keep changes in sync.
       elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
         CallValidation.validate_call(self, original_method, method_sig, args, blk)
+      elsif T::Configuration::AT_LEAST_RUBY_2_7
+        original_method.bind_call(self, *args, &blk)
       else
         original_method.bind(self).call(*args, &blk)
       end

data/lib/types/private/methods/call_validation.rb

@@ -77,790 +77,6 @@ module T::Private::Methods::CallValidation
     mod.send(original_visibility, method_sig.method_name)
   end
 
-  def self.create_validator_method_fast(mod, original_method, method_sig)
-    if method_sig.return_type.is_a?(T::Private::Types::Void)
-      raise "Should have used create_validator_procedure_fast"
-    end
-    # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
-      create_validator_method_fast0(mod, original_method, method_sig, method_sig.return_type.raw_type)
-    elsif method_sig.arg_types.length == 1
-      create_validator_method_fast1(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
-      create_validator_method_fast2(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
-      create_validator_method_fast3(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
-      create_validator_method_fast4(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
-    else
-      raise "should not happen"
-    end
-  end
-
-  def self.create_validator_method_fast0(mod, original_method, method_sig, return_type)
-    mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
-      # This method is a manually sped-up version of more general code in `validate_call`
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(&blk)
-      if should_sample
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast1(mod, original_method, method_sig, return_type, arg0_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
-      # This method is a manually sped-up version of more general code in `validate_call`
-
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, &blk)
-      if should_sample
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast2(mod, original_method, method_sig, return_type, arg0_type, arg1_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
-      # This method is a manually sped-up version of more general code in `validate_call`
-
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, arg1, &blk)
-      if should_sample
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast3(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
-      # This method is a manually sped-up version of more general code in `validate_call`
-
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      if should_sample
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast4(mod, original_method, method_sig, return_type,
-      arg0_type, arg1_type, arg2_type, arg3_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
-      # This method is a manually sped-up version of more general code in `validate_call`
-
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      unless arg3.is_a?(arg3_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[3][1].error_message_for_obj(arg3),
-          'Parameter',
-          method_sig.arg_types[3][0],
-          arg3_type,
-          arg3,
-          caller_offset: -1
-        )
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      if should_sample
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_procedure_fast(mod, original_method, method_sig)
-    # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
-      create_validator_procedure_fast0(mod, original_method, method_sig)
-    elsif method_sig.arg_types.length == 1
-      create_validator_procedure_fast1(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
-      create_validator_procedure_fast2(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
-      create_validator_procedure_fast3(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
-      create_validator_procedure_fast4(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
-    else
-      raise "should not happen"
-    end
-  end
-
-  def self.create_validator_procedure_fast0(mod, original_method, method_sig)
-    mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
-      # This method is a manually sped-up version of more general code in `validate_call`
-
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(&blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast1(mod, original_method, method_sig, arg0_type)
-
-    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
-      # This method is a manually sped-up version of more general code in `validate_call`
-
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-      original_method.bind(self).call(arg0, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast2(mod, original_method, method_sig, arg0_type, arg1_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
-      # This method is a manually sped-up version of more general code in `validate_call`
-
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, arg1, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast3(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
-      # This method is a manually sped-up version of more general code in `validate_call`
-
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast4(mod, original_method, method_sig,
-    arg0_type, arg1_type, arg2_type, arg3_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This block is called for every `sig`. It's critical to keep it fast and
-      # reduce number of allocations that happen here.
-      # This method is a manually sped-up version of more general code in `validate_call`
-
-      T::Profile.typecheck_sample_attempts -= 1
-      should_sample = T::Profile.typecheck_sample_attempts == 0
-      if should_sample
-        T::Profile.typecheck_sample_attempts = T::Profile::SAMPLE_RATE
-        T::Profile.typecheck_samples += 1
-        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      unless arg3.is_a?(arg3_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[3][1].error_message_for_obj(arg3),
-          'Parameter',
-          method_sig.arg_types[3][0],
-          arg3_type,
-          arg3,
-          caller_offset: -1
-        )
-      end
-
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
   def self.create_validator_slow(mod, original_method, method_sig)
     mod.send(:define_method, method_sig.method_name) do |*args, &blk|
       CallValidation.validate_call(self, original_method, method_sig, args, blk)
@@ -946,7 +162,7 @@ module T::Private::Methods::CallValidation
     # this code is sig validation code.
     # Please issue `finish` to step out of it
 
-    return_value = original_method.bind(instance).call(*args, &blk)
+    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
     if should_sample
       t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
@@ -1007,3 +223,9 @@ module T::Private::Methods::CallValidation
     end
   end
 end
+
+if T::Configuration::AT_LEAST_RUBY_2_7
+  require_relative './call_validation_2_7'
+else
+  require_relative './call_validation_2_6'
+end