module T::Private::Methods::CallValidation

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, original_visibility)
      elsif simple_procedure
        create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
      elsif ok_for_fast_path && method_sig.return_type.is_a?(T::Private::Types::Void)
        create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
      elsif ok_for_fast_path
        create_validator_method_medium(mod, original_method, method_sig, original_visibility)
      else
        create_validator_slow(mod, original_method, method_sig, original_visibility)
      end
    end
    mod.send(original_visibility, method_sig.method_name)
  end
end

def self.create_validator_method_fast(mod, original_method, method_sig, original_visibility)
  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, original_visibility, method_sig.return_type.raw_type)
  elsif method_sig.arg_types.length == 1
    create_validator_method_fast1(mod, original_method, method_sig, original_visibility, 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, original_visibility, 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, original_visibility, 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, original_visibility, 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_fast(mod, original_method, method_sig, original_visibility)
  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, original_visibility, method_sig.return_type.raw_type)
  elsif method_sig.arg_types.length == 1
    create_validator_method_fast1(mod, original_method, method_sig, original_visibility, 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, original_visibility, 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, original_visibility, 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, original_visibility, 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, original_visibility, return_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    # 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)
    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
    return_value
  end
end

def self.create_validator_method_fast0(mod, original_method, method_sig, original_visibility, return_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    # 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_call(self, &blk)
    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
    return_value
  end
end

def self.create_validator_method_fast1(mod, original_method, method_sig, original_visibility, return_type, arg0_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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)
    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
    return_value
  end
end

def self.create_validator_method_fast1(mod, original_method, method_sig, original_visibility, return_type, arg0_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_call(self, arg0, &blk)
    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
    return_value
  end
end

def self.create_validator_method_fast2(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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)
    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
    return_value
  end
end

def self.create_validator_method_fast2(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_call(self, arg0, arg1, &blk)
    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
    return_value
  end
end

def self.create_validator_method_fast3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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)
    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
    return_value
  end
end

def self.create_validator_method_fast3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_call(self, arg0, arg1, arg2, &blk)
    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
    return_value
  end
end

def self.create_validator_method_fast4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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)
    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
    return_value
  end
end

def self.create_validator_method_fast4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_call(self, arg0, arg1, arg2, arg3, &blk)
    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
    return_value
  end
end

def self.create_validator_method_medium(mod, original_method, method_sig, original_visibility)
  if method_sig.return_type.is_a?(T::Private::Types::Void)
    raise 'Should have used create_validator_procedure_medium'
  end
  # trampoline to reduce stack frame size
  if method_sig.arg_types.empty?
    create_validator_method_medium0(mod, original_method, method_sig, original_visibility, method_sig.return_type)
  elsif method_sig.arg_types.length == 1
    create_validator_method_medium1(mod, original_method, method_sig, original_visibility, method_sig.return_type,
                                  method_sig.arg_types[0][1])
  elsif method_sig.arg_types.length == 2
    create_validator_method_medium2(mod, original_method, method_sig, original_visibility, method_sig.return_type,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1])
  elsif method_sig.arg_types.length == 3
    create_validator_method_medium3(mod, original_method, method_sig, original_visibility, method_sig.return_type,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1],
                                  method_sig.arg_types[2][1])
  elsif method_sig.arg_types.length == 4
    create_validator_method_medium4(mod, original_method, method_sig, original_visibility, method_sig.return_type,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1],
                                  method_sig.arg_types[2][1],
                                  method_sig.arg_types[3][1])
  else
    raise 'should not happen'
  end
end

def self.create_validator_method_medium(mod, original_method, method_sig, original_visibility)
  if method_sig.return_type.is_a?(T::Private::Types::Void)
    raise 'Should have used create_validator_procedure_medium'
  end
  # trampoline to reduce stack frame size
  if method_sig.arg_types.empty?
    create_validator_method_medium0(mod, original_method, method_sig, original_visibility, method_sig.return_type)
  elsif method_sig.arg_types.length == 1
    create_validator_method_medium1(mod, original_method, method_sig, original_visibility, method_sig.return_type,
                                  method_sig.arg_types[0][1])
  elsif method_sig.arg_types.length == 2
    create_validator_method_medium2(mod, original_method, method_sig, original_visibility, method_sig.return_type,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1])
  elsif method_sig.arg_types.length == 3
    create_validator_method_medium3(mod, original_method, method_sig, original_visibility, method_sig.return_type,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1],
                                  method_sig.arg_types[2][1])
  elsif method_sig.arg_types.length == 4
    create_validator_method_medium4(mod, original_method, method_sig, original_visibility, method_sig.return_type,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1],
                                  method_sig.arg_types[2][1],
                                  method_sig.arg_types[3][1])
  else
    raise 'should not happen'
  end
end

def self.create_validator_method_medium0(mod, original_method, method_sig, original_visibility, return_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    # 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)
    unless return_type.valid?(return_value)
      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
    return_value
  end
end

def self.create_validator_method_medium0(mod, original_method, method_sig, original_visibility, return_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    # 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_call(self, &blk)
    unless return_type.valid?(return_value)
      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
    return_value
  end
end

def self.create_validator_method_medium1(mod, original_method, method_sig, original_visibility, return_type, arg0_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    unless arg0_type.valid?(arg0)
      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
    # 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)
    unless return_type.valid?(return_value)
      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
    return_value
  end
end

def self.create_validator_method_medium1(mod, original_method, method_sig, original_visibility, return_type, arg0_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    unless arg0_type.valid?(arg0)
      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
    # 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_call(self, arg0, &blk)
    unless return_type.valid?(return_value)
      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
    return_value
  end
end

def self.create_validator_method_medium2(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    unless arg0_type.valid?(arg0)
      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_type.valid?(arg1)
      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
    # 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)
    unless return_type.valid?(return_value)
      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
    return_value
  end
end

def self.create_validator_method_medium2(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    unless arg0_type.valid?(arg0)
      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_type.valid?(arg1)
      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
    # 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_call(self, arg0, arg1, &blk)
    unless return_type.valid?(return_value)
      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
    return_value
  end
end

def self.create_validator_method_medium3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    unless arg0_type.valid?(arg0)
      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_type.valid?(arg1)
      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_type.valid?(arg2)
      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
    # 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)
    unless return_type.valid?(return_value)
      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
    return_value
  end
end

def self.create_validator_method_medium3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    unless arg0_type.valid?(arg0)
      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_type.valid?(arg1)
      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_type.valid?(arg2)
      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
    # 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_call(self, arg0, arg1, arg2, &blk)
    unless return_type.valid?(return_value)
      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
    return_value
  end
end

def self.create_validator_method_medium4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    unless arg0_type.valid?(arg0)
      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_type.valid?(arg1)
      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_type.valid?(arg2)
      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_type.valid?(arg3)
      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
    # 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)
    unless return_type.valid?(return_value)
      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
    return_value
  end
end

def self.create_validator_method_medium4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    unless arg0_type.valid?(arg0)
      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_type.valid?(arg1)
      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_type.valid?(arg2)
      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_type.valid?(arg3)
      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
    # 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_call(self, arg0, arg1, arg2, arg3, &blk)
    unless return_type.valid?(return_value)
      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
    return_value
  end
end

def self.create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
  # trampoline to reduce stack frame size
  if method_sig.arg_types.empty?
    create_validator_procedure_fast0(mod, original_method, method_sig, original_visibility)
  elsif method_sig.arg_types.length == 1
    create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility,
                                  method_sig.arg_types[0][1].raw_type)
  elsif method_sig.arg_types.length == 2
    create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility,
                                  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, original_visibility,
                                  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, original_visibility,
                                  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_fast(mod, original_method, method_sig, original_visibility)
  # trampoline to reduce stack frame size
  if method_sig.arg_types.empty?
    create_validator_procedure_fast0(mod, original_method, method_sig, original_visibility)
  elsif method_sig.arg_types.length == 1
    create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility,
                                  method_sig.arg_types[0][1].raw_type)
  elsif method_sig.arg_types.length == 2
    create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility,
                                  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, original_visibility,
                                  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, original_visibility,
                                  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, original_visibility)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    # 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_fast0(mod, original_method, method_sig, original_visibility)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    # 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_call(self, &blk)
    T::Private::Types::Void::VOID
  end
end

def self.create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility, arg0_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_fast1(mod, original_method, method_sig, original_visibility, arg0_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_call(self, arg0, &blk)
    T::Private::Types::Void::VOID
  end
end

def self.create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_fast2(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_call(self, arg0, arg1, &blk)
    T::Private::Types::Void::VOID
  end
end

def self.create_validator_procedure_fast3(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_fast3(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_call(self, arg0, arg1, arg2, &blk)
    T::Private::Types::Void::VOID
  end
end

def self.create_validator_procedure_fast4(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type, arg3_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_procedure_fast4(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type, arg3_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    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
    # 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_call(self, arg0, arg1, arg2, arg3, &blk)
    T::Private::Types::Void::VOID
  end
end

def self.create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
  # trampoline to reduce stack frame size
  if method_sig.arg_types.empty?
    create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
  elsif method_sig.arg_types.length == 1
    create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility,
                                  method_sig.arg_types[0][1])
  elsif method_sig.arg_types.length == 2
    create_validator_procedure_medium2(mod, original_method, method_sig, original_visibility,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1])
  elsif method_sig.arg_types.length == 3
    create_validator_procedure_medium3(mod, original_method, method_sig, original_visibility,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1],
                                  method_sig.arg_types[2][1])
  elsif method_sig.arg_types.length == 4
    create_validator_procedure_medium4(mod, original_method, method_sig, original_visibility,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1],
                                  method_sig.arg_types[2][1],
                                  method_sig.arg_types[3][1])
  else
    raise 'should not happen'
  end
end

def self.create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
  # trampoline to reduce stack frame size
  if method_sig.arg_types.empty?
    create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
  elsif method_sig.arg_types.length == 1
    create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility,
                                  method_sig.arg_types[0][1])
  elsif method_sig.arg_types.length == 2
    create_validator_procedure_medium2(mod, original_method, method_sig, original_visibility,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1])
  elsif method_sig.arg_types.length == 3
    create_validator_procedure_medium3(mod, original_method, method_sig, original_visibility,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1],
                                  method_sig.arg_types[2][1])
  elsif method_sig.arg_types.length == 4
    create_validator_procedure_medium4(mod, original_method, method_sig, original_visibility,
                                  method_sig.arg_types[0][1],
                                  method_sig.arg_types[1][1],
                                  method_sig.arg_types[2][1],
                                  method_sig.arg_types[3][1])
  else
    raise 'should not happen'
  end
end

def self.create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    # 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_medium0(mod, original_method, method_sig, original_visibility)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    # 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_call(self, &blk)
    T::Private::Types::Void::VOID
  end
end

def self.create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility, arg0_type)
  T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
    # This method is a manually sped-up version of more general code in `validate_call`
    unless arg0_type.valid?(arg0)
      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
    # 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