1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
//===- TypeTraitsTest.cpp - type_traits unit tests ------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/STLExtras.h"
#include "gtest/gtest.h"
using namespace llvm;
//===----------------------------------------------------------------------===//
// function_traits
//===----------------------------------------------------------------------===//
namespace {
/// Check a callable type of the form `bool(const int &)`.
template <typename CallableT> struct CheckFunctionTraits {
static_assert(
std::is_same<typename function_traits<CallableT>::result_t, bool>::value,
"expected result_t to be `bool`");
static_assert(
std::is_same<typename function_traits<CallableT>::template arg_t<0>,
const int &>::value,
"expected arg_t<0> to be `const int &`");
static_assert(function_traits<CallableT>::num_args == 1,
"expected num_args to be 1");
};
/// Test function pointers.
using FuncType = bool (*)(const int &);
struct CheckFunctionPointer : CheckFunctionTraits<FuncType> {};
/// Test method pointers.
struct Foo {
bool func(const int &v);
};
struct CheckMethodPointer : CheckFunctionTraits<decltype(&Foo::func)> {};
/// Test lambda references.
LLVM_ATTRIBUTE_UNUSED auto lambdaFunc = [](const int &v) -> bool {
return true;
};
struct CheckLambda : CheckFunctionTraits<decltype(lambdaFunc)> {};
} // end anonymous namespace
//===----------------------------------------------------------------------===//
// is_detected
//===----------------------------------------------------------------------===//
namespace {
struct HasFooMethod {
void foo() {}
};
struct NoFooMethod {};
template <class T> using has_foo_method_t = decltype(std::declval<T &>().foo());
static_assert(is_detected<has_foo_method_t, HasFooMethod>::value,
"expected foo method to be detected");
static_assert(!is_detected<has_foo_method_t, NoFooMethod>::value,
"expected no foo method to be detected");
} // end anonymous namespace
//===----------------------------------------------------------------------===//
// is_invocable
//===----------------------------------------------------------------------===//
void invocable_fn(int);
static_assert(is_invocable<decltype(invocable_fn), int>::value,
"expected function to be invocable");
static_assert(!is_invocable<decltype(invocable_fn), void *>::value,
"expected function not to be invocable");
static_assert(!is_invocable<decltype(invocable_fn), int, int>::value,
"expected function not to be invocable");
|
