clang/test/Parser/generic-selection-type-extension.c

   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
   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
  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)>
  65 constexpr Ty bar() { return N; }
  66
  67 static_assert(bar<int>() == 0);
  68 static_assert(bar<float>() == 1);
  69 #endif // __cplusplus