sorbet-runtime 0.5.6295 → 0.5.6483

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

@@ -27,6 +27,8 @@ module T::Private::Methods::CallValidation
           )
         end
       end
+    # Do nothing in this case; this method was not wrapped in _on_method_added.
+    elsif method_sig.defined_raw
     # Note, this logic is duplicated (intentionally, for micro-perf) at `Methods._on_method_added`,
     # make sure to keep changes in sync.
     # This is a trapdoor point for each method:
@@ -47,18 +49,55 @@ module T::Private::Methods::CallValidation
     mod.instance_method(method_sig.method_name)
   end
 
+  @is_allowed_to_have_fast_path = true
+  def self.is_allowed_to_have_fast_path
+    @is_allowed_to_have_fast_path
+  end
+
+  def self.disable_fast_path
+    @is_allowed_to_have_fast_path = false
+  end
+
+  def self.create_validator_method(mod, original_method, method_sig, original_visibility)
+    has_fixed_arity = method_sig.kwarg_types.empty? && !method_sig.has_rest && !method_sig.has_keyrest &&
+      original_method.parameters.all? {|(kind, _name)| kind == :req}
+    ok_for_fast_path = has_fixed_arity && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+
+    all_args_are_simple = ok_for_fast_path && method_sig.arg_types.all? {|_name, type| type.is_a?(T::Types::Simple)}
+    simple_method = all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
+    simple_procedure = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
+
+    T::Configuration.without_ruby_warnings do
+      T::Private::DeclState.current.without_on_method_added do
+        if simple_method
+          create_validator_method_fast(mod, original_method, method_sig)
+        elsif simple_procedure
+          create_validator_procedure_fast(mod, original_method, method_sig)
+        elsif ok_for_fast_path && method_sig.return_type.is_a?(T::Private::Types::Void)
+          create_validator_procedure_medium(mod, original_method, method_sig)
+        elsif ok_for_fast_path
+          create_validator_method_medium(mod, original_method, method_sig)
+        else
+          create_validator_slow(mod, original_method, method_sig)
+        end
+      end
+    end
+    mod.send(original_visibility, method_sig.method_name)
+  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)
+    end
+    if mod.respond_to?(:ruby2_keywords, true)
+      mod.send(:ruby2_keywords, method_sig.method_name)
+    end
+  end
+
   def self.validate_call(instance, original_method, method_sig, args, blk)
     # This method is called for every `sig`. It's critical to keep it fast and
     # reduce number of allocations that happen here.
 
-    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 method_sig.bind
       message = method_sig.bind.error_message_for_obj(instance)
       if message
@@ -104,10 +143,6 @@ module T::Private::Methods::CallValidation
       end
     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
 
 
@@ -123,10 +158,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)
-    if should_sample
-      t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
+    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
 
     # The only type that is allowed to change the return value is `.void`.
     # It ignores what you returned and changes it to be a private singleton.
@@ -144,976 +176,10 @@ module T::Private::Methods::CallValidation
           return_value,
         )
       end
-      if should_sample
-        T::Profile.typecheck_duration += (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1)
-      end
-      return_value
-    end
-  end
-
-  @is_allowed_to_have_fast_path = true
-  def self.is_allowed_to_have_fast_path
-    @is_allowed_to_have_fast_path
-  end
-
-  def self.disable_fast_path
-    @is_allowed_to_have_fast_path = false
-  end
-
-  def self.create_validator_method(mod, original_method, method_sig, original_visibility)
-    has_fixed_arity = method_sig.kwarg_types.empty? && !method_sig.has_rest && !method_sig.has_keyrest &&
-      original_method.parameters.all? {|(kind, _name)| kind == :req}
-    all_args_are_simple = method_sig.arg_types.all? {|_name, type| type.is_a?(T::Types::Simple)}
-    has_simple_method_types =  all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
-    has_simple_procedure_types = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
-
-    T::Configuration.without_ruby_warnings do
-      T::Private::DeclState.current.without_on_method_added do
-        if has_fixed_arity && has_simple_method_types && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
-          create_validator_method_fast(mod, original_method, method_sig)
-        elsif has_fixed_arity && has_simple_procedure_types && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
-          create_validator_procedure_fast(mod, original_method, method_sig)
-        else
-          create_validator_slow(mod, original_method, method_sig)
-        end
-      end
-    end
-    mod.send(original_visibility, method_sig.method_name)
-  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)
-    end
-    if mod.respond_to?(:ruby2_keywords, true)
-      mod.send(:ruby2_keywords, method_sig.method_name)
-    end
-  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 method_sig.bind
-        message = method_sig.bind.error_message_for_obj(self)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Bind',
-            nil,
-            method_sig.bind,
-            self
-          )
-        end
-      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
-
-      if method_sig.bind
-        message = method_sig.bind.error_message_for_obj(self)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Bind',
-            nil,
-            method_sig.bind,
-            self
-          )
-        end
-      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
-
-      if method_sig.bind
-        message = method_sig.bind.error_message_for_obj(self)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Bind',
-            nil,
-            method_sig.bind,
-            self
-          )
-        end
-      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
-
-      if method_sig.bind
-        message = method_sig.bind.error_message_for_obj(self)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Bind',
-            nil,
-            method_sig.bind,
-            self
-          )
-        end
-      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
-
-      if method_sig.bind
-        message = method_sig.bind.error_message_for_obj(self)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Bind',
-            nil,
-            method_sig.bind,
-            self
-          )
-        end
-      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 method_sig.bind
-        message = method_sig.bind.error_message_for_obj(self)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Bind',
-            nil,
-            method_sig.bind,
-            self
-          )
-        end
-      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
-
-      if method_sig.bind
-        message = method_sig.bind.error_message_for_obj(self)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Bind',
-            nil,
-            method_sig.bind,
-            self
-          )
-        end
-      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
-
-      if method_sig.bind
-        message = method_sig.bind.error_message_for_obj(self)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Bind',
-            nil,
-            method_sig.bind,
-            self
-          )
-        end
-      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
-
-      if method_sig.bind
-        message = method_sig.bind.error_message_for_obj(self)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Bind',
-            nil,
-            method_sig.bind,
-            self
-          )
-        end
-      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
-
-      if method_sig.bind
-        message = method_sig.bind.error_message_for_obj(self)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Bind',
-            nil,
-            method_sig.bind,
-            self
-          )
-        end
-      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.report_error(method_sig, error_message, kind, name, type, value, caller_offset: 0)
     caller_loc = T.must(caller_locations(3 + caller_offset, 1))[0]
     definition_file, definition_line = method_sig.method.source_location
@@ -1147,3 +213,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