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
80
81
82
83
84
85
86
87
88
89
90
91
92
|
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s -Wno-c++17-extensions
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s -Wno-c++17-extensions
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
// RUN: %clang_cc1 -x c -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu11 -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
#ifdef __cplusplus
// expected-no-diagnostics
using Int = int;
struct NonPOD { NonPOD(int); };
enum Enum { EV };
struct POD { Enum e; int i; float f; NonPOD* p; };
struct Derives : POD {};
using ClassType = Derives;
union Union { int i; float f; };
struct HasAnonymousUnion {
union {
int i;
float f;
};
};
struct FinalClass final {
};
template<typename T>
struct PotentiallyFinal { };
template<typename T>
struct PotentiallyFinal<T*> final { };
template<>
struct PotentiallyFinal<int> final { };
struct SealedClass sealed {
};
template<typename T>
struct PotentiallySealed { };
template<typename T>
struct PotentiallySealed<T*> sealed { };
template<>
struct PotentiallySealed<int> sealed { };
void is_final() {
static_assert(__is_final(SealedClass));
static_assert(__is_final(PotentiallySealed<float*>));
static_assert(__is_final(PotentiallySealed<int>));
static_assert(!__is_final(PotentiallyFinal<float>));
static_assert(!__is_final(PotentiallySealed<float>));
}
void is_sealed()
{
static_assert(__is_sealed(SealedClass));
static_assert(__is_sealed(PotentiallySealed<float*>));
static_assert(__is_sealed(PotentiallySealed<int>));
static_assert(__is_sealed(FinalClass));
static_assert(__is_sealed(PotentiallyFinal<float*>));
static_assert(__is_sealed(PotentiallyFinal<int>));
static_assert(!__is_sealed(int));
static_assert(!__is_sealed(Union));
static_assert(!__is_sealed(Int));
static_assert(!__is_sealed(Int[10]));
static_assert(!__is_sealed(Union[10]));
static_assert(!__is_sealed(Derives));
static_assert(!__is_sealed(ClassType));
static_assert(!__is_sealed(const void));
static_assert(!__is_sealed(Int[]));
static_assert(!__is_sealed(HasAnonymousUnion));
static_assert(!__is_sealed(PotentiallyFinal<float>));
static_assert(!__is_sealed(PotentiallySealed<float>));
}
#else
struct s1 {};
void is_destructible()
{
(void)__is_destructible(int);
(void)__is_destructible(struct s1);
(void)__is_destructible(struct s2); // expected-error{{incomplete type 'struct s2' used in type trait expression}}
// expected-note@-1{{}}
}
#endif
|
