1 // RUN: %clang_cc1 -std=c2x -fsyntax-only -verify -Wno-unused %s
2 // RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp -Wno-unused -x c++ -std=c++17 %s
3
4 // Test various parsing situations for the Clang extension to _Generic which
5 // accepts a type name instead of an expression as the first operand.
6
7 int foo();
8
test()9 void test() {
10 // We can parse a simple type name.
11 _Generic(int, int : 0);
12
13 // We can also parse tag types.
14 struct S { int i; };
15 enum E { A };
16 union U { int i; };
17 _Generic(struct S, default : 0);
18 _Generic(enum E, default : 0);
19 _Generic(union U, default : 0);
20
21 // We can also parse array types.
22 _Generic(int[12], default : 0);
23
24 // And pointer to array types, too.
25 _Generic(int(*)[12], default : 0);
26
27 // We do not accept a parenthesized type name.
28 _Generic((int), int : 0); // expected-error {{expected expression}}
29
30 // We can parse more complex types as well. Note, this is a valid spelling of
31 // a function pointer type in C but is not a valid spelling of a function
32 // pointer type in C++. Surprise!
33 _Generic(__typeof__(foo())(*)(__typeof__(&foo)), int (*)(int (*)()) : 0); // cpp-error {{expected expression}} \
34 cpp-error {{expected '(' for function-style cast or type construction}}
35
36 // C being the magical language that it is, lets you define a type anywhere
37 // you can spell a type.
38 _Generic(struct T { int a; }, default : 0); // cpp-error {{'T' cannot be defined in a type specifier}}
39 }
40
41 #ifdef __cplusplus
42 template <typename Ty>
43 struct S {
44 template <template <typename> typename Uy>
45 struct T {
46 typedef typename Uy<Ty>::type foo;
47 };
48 };
49
50 template <typename Ty>
51 struct inst {
52 typedef Ty type;
53 };
54
cpp_test()55 void cpp_test() {
56 // Ensure we can parse more complex C++ typenames as well.
57 _Generic(S<int>::T<inst>::foo, int : 1);
58
59 // And that the type name doesn't confuse us when given an initialization
60 // expression.
61 _Generic(S<int>::T<inst>::foo{}, int : 1);
62 }
63
64 template <typename Ty, int N = _Generic(Ty, int : 0, default : 1)>
bar()65 constexpr Ty bar() { return N; }
66
67 static_assert(bar<int>() == 0);
68 static_assert(bar<float>() == 1);
69 #endif // __cplusplus
70