clang/test/SemaCXX/generic-selection.cpp

   1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
   2
   3 template <typename T, typename U = void*>
   4 struct A {
   5   enum {
   6     id = _Generic(T(), // expected-error {{controlling expression type 'char' not compatible with any generic association type}}
   7         int: 1, // expected-note {{compatible type 'int' specified here}}
   8         float: 2,
   9         U: 3) // expected-error {{type 'int' in generic association compatible with previously specified type 'int'}}
  10   };
  11 };
  12
  13 static_assert(A<int>::id == 1, "fail");
  14 static_assert(A<float>::id == 2, "fail");
  15 static_assert(A<double, double>::id == 3, "fail");
  16
  17 A<char> a1; // expected-note {{in instantiation of template class 'A<char>' requested here}}
  18 A<short, int> a2; // expected-note {{in instantiation of template class 'A<short, int>' requested here}}
  19
  20 template <typename T, typename U>
  21 struct B {
  22   enum {
  23     id = _Generic(T(),
  24         int: 1, // expected-note {{compatible type 'int' specified here}}
  25         int: 2, // expected-error {{type 'int' in generic association compatible with previously specified type 'int'}}
  26         U: 3)
  27   };
  28 };
  29
  30 template <unsigned Arg, unsigned... Args> struct Or {
  31   enum { result = Arg | Or<Args...>::result };
  32 };
  33
  34 template <unsigned Arg> struct Or<Arg> {
  35   enum { result = Arg };
  36 };
  37
  38 template <class... Args> struct TypeMask {
  39   enum {
  40    result = Or<_Generic(Args(), int: 1, long: 2, short: 4, float: 8)...>::result
  41   };
  42 };
  43
  44 static_assert(TypeMask<int, long, short>::result == 7, "fail");
  45 static_assert(TypeMask<float, short>::result == 12, "fail");
  46 static_assert(TypeMask<int, float, float>::result == 9, "fail");
  47
  48
  49 struct Test {
  50   int i;
  51 };
  52
  53 void unreachable_associations(const int i, const Test t) {
  54   // FIXME: it's not clear to me whether we intended to deviate from the C
  55   // semantics in terms of how qualifiers are handled, so this documents the
  56   // existing behavior but perhaps not the desired behavior.
  57   static_assert(
  58     _Generic(i,
  59       const int : 1,    // expected-warning {{due to lvalue conversion of the controlling expression, association of type 'const int' will never be selected because it is qualified}}
  60       volatile int : 2, // expected-warning {{due to lvalue conversion of the controlling expression, association of type 'volatile int' will never be selected because it is qualified}}
  61       int[12] : 3,      // expected-warning {{due to lvalue conversion of the controlling expression, association of type 'int[12]' will never be selected because it is of array type}}
  62       int : 4,
  63       default : 5
  64     ) == 4, "we had better pick int, not const int!");
  65   static_assert(
  66     _Generic(t,
  67       Test : 1,
  68       const Test : 2,  // Ok in C++, warned in C
  69       default : 3
  70     ) == 2, "we had better pick const Test, not Test!"); // C++-specific result
  71 }
  72
  73 namespace GH55562 {
  74 struct S { // expected-note {{declared here}}
  75   int i;
  76 };
  77
  78 void func(struct S s) {
  79   // We would previously reject this because the parser thought 'struct S :'
  80   // was the start of a definition (with a base class specifier); it's not, it
  81   // is an elaborated type specifier followed by the association's value and
  82   // it should work the same as in C.
  83   (void)_Generic(s, struct S : 1);
  84
  85   // The rest of these cases test that we still produce a reasonable diagnostic
  86   // when referencing an unknown type or trying to define a type in other ways.
  87   (void)_Generic(s, struct T : 1);            // expected-error {{type 'struct T' in generic association incomplete}}
  88   (void)_Generic(s, struct U { int a; } : 1); // expected-error {{'U' cannot be defined in a type specifier}}
  89   (void)_Generic(s, struct V : S);            // expected-error {{'S' does not refer to a value}}
  90   (void)_Generic(s, struct W : S { int b; } : 1); // expected-error {{expected '(' for function-style cast or type construction}}
  91 }
  92 } // namespace GH55562