RubyGems - sorbet-runtime - Versions diffs - 0.5.6307 → 0.5.6317 - Mend

sorbet-runtime 0.5.6307 → 0.5.6317

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

checksums.yaml +4 -4
data/lib/types/configuration.rb +9 -1
data/lib/types/private/methods/_methods.rb +3 -4
data/lib/types/private/methods/call_validation.rb +7 -785
data/lib/types/private/methods/call_validation_2_6.rb +781 -0
data/lib/types/private/methods/call_validation_2_7.rb +781 -0
data/lib/types/types/typed_enumerable.rb +5 -1
data/lib/types/utils.rb +7 -0
metadata +4 -2

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fd04bbc68f93977066be4b2fb798b27781baaed1bb9ab647d2e5e2adbe8304b
-  data.tar.gz: 731a5313c3a738a9fd8c1b8b378c71ee280ae8fa1fdcf8f28b1fe4af8b702fc9
+  metadata.gz: '097683b0eba207cf9b04accf22d9dcf1661848f4d5e1254b34e3e3240b160351'
+  data.tar.gz: cf2c97818079eba96e2eeba28b05844ce8ac8adb5c69ae940ad6031d6bdd9e43
 SHA512:
-  metadata.gz: a4d105eb0fb168fa50cd55c84b877e16970d56333b664f2b031c0a06b2930b31a148358fcf2e2b5f472f428ef573f8303ee493729c6fc87133ab628dde001584
-  data.tar.gz: 2b8d7c25760ac6d24a24d6031e188af593df356569e66471198e61cfec2ba76d3c98cf909bde966272829234742bd9e88a5d11a5be0cc90bf9fa1c33ec9feed7
+  metadata.gz: 221da0912324d1e0ab19d23ac4fb6c30fc1ba2a9db54b9eb466e807a1093205fe5393564a1a40783e7dee15bc167afa4f1f88445b12e1364e80120b0f00853ee
+  data.tar.gz: '0893b271dd3d604514531424bde009256dc0a14d56e4379b5184b27ac01f10d140cb7d467217d854ebacb77489ef1874b324133f69ac2cf1df39c68c53de6b20'

data/lib/types/configuration.rb CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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