116 lines
3.9 KiB
C++
116 lines
3.9 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
// Source Licenses. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// UNSUPPORTED: c++98, c++03, c++11, c++14
|
|
|
|
// type_traits
|
|
|
|
// is_nothrow_callable
|
|
|
|
#include <type_traits>
|
|
#include <functional>
|
|
|
|
#include "test_macros.h"
|
|
|
|
struct Tag {};
|
|
|
|
struct Implicit {
|
|
Implicit(int) noexcept {}
|
|
};
|
|
|
|
struct ThrowsImplicit {
|
|
ThrowsImplicit(int) {}
|
|
};
|
|
|
|
struct Explicit {
|
|
explicit Explicit(int) noexcept {}
|
|
};
|
|
|
|
template <bool IsNoexcept, class Ret, class ...Args>
|
|
struct CallObject {
|
|
Ret operator()(Args&&...) const noexcept(IsNoexcept);
|
|
};
|
|
|
|
template <class Fn>
|
|
constexpr bool throws_callable() {
|
|
return std::is_callable<Fn>::value &&
|
|
!std::is_nothrow_callable<Fn>::value;
|
|
}
|
|
|
|
template <class Fn, class Ret>
|
|
constexpr bool throws_callable() {
|
|
return std::is_callable<Fn, Ret>::value &&
|
|
!std::is_nothrow_callable<Fn, Ret>::value;
|
|
}
|
|
|
|
// FIXME(EricWF) Don't test the where noexcept is *not* part of the type system
|
|
// once implementations have caught up.
|
|
void test_noexcept_function_pointers()
|
|
{
|
|
struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
|
|
#if !defined(__cpp_noexcept_function_type)
|
|
{
|
|
// Check that PMF's and function pointers *work*. is_nothrow_callable will always
|
|
// return false because 'noexcept' is not part of the function type.
|
|
static_assert(throws_callable<decltype(&Dummy::foo)(Dummy&)>(), "");
|
|
static_assert(throws_callable<decltype(&Dummy::bar)()>(), "");
|
|
}
|
|
#else
|
|
{
|
|
// Check that PMF's and function pointers actually work and that
|
|
// is_nothrow_callable returns true for noexcept PMF's and function
|
|
// pointers.
|
|
static_assert(std::is_nothrow_callable<decltype(&Dummy::foo)(Dummy&)>::value, "");
|
|
static_assert(std::is_nothrow_callable<decltype(&Dummy::bar)()>::value, "");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
int main()
|
|
{
|
|
{
|
|
// Check that the conversion to the return type is properly checked
|
|
using Fn = CallObject<true, int>;
|
|
static_assert(std::is_nothrow_callable<Fn(), Implicit>::value, "");
|
|
static_assert(std::is_nothrow_callable<Fn(), double>::value, "");
|
|
static_assert(std::is_nothrow_callable<Fn(), const volatile void>::value, "");
|
|
static_assert(throws_callable<Fn(), ThrowsImplicit>(), "");
|
|
static_assert(!std::is_nothrow_callable<Fn(), Explicit>(), "");
|
|
}
|
|
{
|
|
// Check that the conversion to the parameters is properly checked
|
|
using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
|
|
static_assert(std::is_nothrow_callable<Fn(Implicit&, ThrowsImplicit&)>::value, "");
|
|
static_assert(std::is_nothrow_callable<Fn(int, ThrowsImplicit&)>::value, "");
|
|
static_assert(throws_callable<Fn(int, int)>(), "");
|
|
static_assert(!std::is_nothrow_callable<Fn()>::value, "");
|
|
}
|
|
{
|
|
// Check that the noexcept-ness of function objects is checked.
|
|
using Fn = CallObject<true, void>;
|
|
using Fn2 = CallObject<false, void>;
|
|
static_assert(std::is_nothrow_callable<Fn()>::value, "");
|
|
static_assert(throws_callable<Fn2()>(), "");
|
|
}
|
|
{
|
|
// Check that PMD derefs are noexcept
|
|
using Fn = int (Tag::*);
|
|
static_assert(std::is_nothrow_callable<Fn(Tag&)>::value, "");
|
|
static_assert(std::is_nothrow_callable<Fn(Tag&), Implicit>::value, "");
|
|
static_assert(throws_callable<Fn(Tag&), ThrowsImplicit>(), "");
|
|
}
|
|
{
|
|
// Check for is_nothrow_callable_v
|
|
using Fn = CallObject<true, int>;
|
|
static_assert(std::is_nothrow_callable_v<Fn()>, "");
|
|
static_assert(!std::is_nothrow_callable_v<Fn(int)>, "");
|
|
}
|
|
test_noexcept_function_pointers();
|
|
}
|