test/SemaCXX/type-traits.cpp

   1 // RUN: clang-cc -fsyntax-only -verify %s
   2 #define T(b) (b) ? 1 : -1
   3 #define F(b) (b) ? -1 : 1
   4
   5 struct NonPOD { NonPOD(int); };
   6
   7 // PODs
   8 enum Enum { EV };
   9 struct POD { Enum e; int i; float f; NonPOD* p; };
  10 struct Empty {};
  11 typedef Empty EmptyAr[10];
  12 typedef int Int;
  13 typedef Int IntAr[10];
  14 class Statics { static int priv; static NonPOD np; };
  15 union EmptyUnion {};
  16 union Union { int i; float f; };
  17 struct HasFunc { void f (); };
  18 struct HasOp { void operator *(); };
  19 struct HasConv { operator int(); };
  20 struct HasAssign { void operator =(int); };
  21
  22 // Not PODs
  23 struct Derives : POD {};
  24 struct DerivesEmpty : Empty {};
  25 struct HasCons { HasCons(int); };
  26 struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };
  27 struct HasDest { ~HasDest(); };
  28 class  HasPriv { int priv; };
  29 class  HasProt { protected: int prot; };
  30 struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} };
  31 struct HasNonPOD { NonPOD np; };
  32 struct HasVirt { virtual void Virt() {}; };
  33 typedef Derives NonPODAr[10];
  34 typedef HasVirt VirtAr[10];
  35 union NonPODUnion { int i; Derives n; };
  36
  37 void is_pod()
  38 {
  39   int t01[T(__is_pod(int))];
  40   int t02[T(__is_pod(Enum))];
  41   int t03[T(__is_pod(POD))];
  42   int t04[T(__is_pod(Int))];
  43   int t05[T(__is_pod(IntAr))];
  44   int t06[T(__is_pod(Statics))];
  45   int t07[T(__is_pod(Empty))];
  46   int t08[T(__is_pod(EmptyUnion))];
  47   int t09[T(__is_pod(Union))];
  48   int t10[T(__is_pod(HasFunc))];
  49   int t11[T(__is_pod(HasOp))];
  50   int t12[T(__is_pod(HasConv))];
  51   int t13[T(__is_pod(HasAssign))];
  52
  53   int t21[F(__is_pod(Derives))];
  54   int t22[F(__is_pod(HasCons))];
  55   int t23[F(__is_pod(HasCopyAssign))];
  56   int t24[F(__is_pod(HasDest))];
  57   int t25[F(__is_pod(HasPriv))];
  58   int t26[F(__is_pod(HasProt))];
  59   int t27[F(__is_pod(HasRef))];
  60   int t28[F(__is_pod(HasNonPOD))];
  61   int t29[F(__is_pod(HasVirt))];
  62   int t30[F(__is_pod(NonPODAr))];
  63   int t31[F(__is_pod(DerivesEmpty))];
  64  // int t32[F(__is_pod(NonPODUnion))];
  65 }
  66
  67 typedef Empty EmptyAr[10];
  68 struct Bit0 { int : 0; };
  69 struct Bit0Cons { int : 0; Bit0Cons(); };
  70 struct BitOnly { int x : 3; };
  71 //struct DerivesVirt : virtual POD {};
  72
  73 void is_empty()
  74 {
  75   int t01[T(__is_empty(Empty))];
  76   int t02[T(__is_empty(DerivesEmpty))];
  77   int t03[T(__is_empty(HasCons))];
  78   int t04[T(__is_empty(HasCopyAssign))];
  79   int t05[T(__is_empty(HasDest))];
  80   int t06[T(__is_empty(HasFunc))];
  81   int t07[T(__is_empty(HasOp))];
  82   int t08[T(__is_empty(HasConv))];
  83   int t09[T(__is_empty(HasAssign))];
  84   int t10[T(__is_empty(Bit0))];
  85   int t11[T(__is_empty(Bit0Cons))];
  86
  87   int t21[F(__is_empty(Int))];
  88   int t22[F(__is_empty(POD))];
  89   int t23[F(__is_empty(EmptyUnion))];
  90   int t24[F(__is_empty(EmptyAr))];
  91   int t25[F(__is_empty(HasRef))];
  92   int t26[F(__is_empty(HasVirt))];
  93   int t27[F(__is_empty(BitOnly))];
  94 //  int t27[F(__is_empty(DerivesVirt))];
  95 }
  96
  97 typedef Derives ClassType;
  98
  99 void is_class()
 100 {
 101   int t01[T(__is_class(Derives))];
 102   int t02[T(__is_class(HasPriv))];
 103   int t03[T(__is_class(ClassType))];
 104
 105   int t11[F(__is_class(int))];
 106   int t12[F(__is_class(Enum))];
 107   int t13[F(__is_class(Int))];
 108   int t14[F(__is_class(IntAr))];
 109   int t15[F(__is_class(NonPODAr))];
 110   int t16[F(__is_class(Union))];
 111 }
 112
 113 typedef Union UnionAr[10];
 114 typedef Union UnionType;
 115
 116 void is_union()
 117 {
 118   int t01[T(__is_union(Union))];
 119   int t02[T(__is_union(UnionType))];
 120
 121   int t11[F(__is_union(int))];
 122   int t12[F(__is_union(Enum))];
 123   int t13[F(__is_union(Int))];
 124   int t14[F(__is_union(IntAr))];
 125   int t15[F(__is_union(UnionAr))];
 126 }
 127
 128 typedef Enum EnumType;
 129
 130 void is_enum()
 131 {
 132   int t01[T(__is_enum(Enum))];
 133   int t02[T(__is_enum(EnumType))];
 134
 135   int t11[F(__is_enum(int))];
 136   int t12[F(__is_enum(Union))];
 137   int t13[F(__is_enum(Int))];
 138   int t14[F(__is_enum(IntAr))];
 139   int t15[F(__is_enum(UnionAr))];
 140   int t16[F(__is_enum(Derives))];
 141   int t17[F(__is_enum(ClassType))];
 142 }
 143
 144 typedef HasVirt Polymorph;
 145 struct InheritPolymorph : Polymorph {};
 146
 147 void is_polymorphic()
 148 {
 149   int t01[T(__is_polymorphic(Polymorph))];
 150   int t02[T(__is_polymorphic(InheritPolymorph))];
 151
 152   int t11[F(__is_polymorphic(int))];
 153   int t12[F(__is_polymorphic(Union))];
 154   int t13[F(__is_polymorphic(Int))];
 155   int t14[F(__is_polymorphic(IntAr))];
 156   int t15[F(__is_polymorphic(UnionAr))];
 157   int t16[F(__is_polymorphic(Derives))];
 158   int t17[F(__is_polymorphic(ClassType))];
 159   int t18[F(__is_polymorphic(Enum))];
 160 }
 161
 162 typedef Int& IntRef;
 163 typedef const IntAr ConstIntAr;
 164 typedef ConstIntAr ConstIntArAr[4];
 165
 166 struct HasCopy {
 167   HasCopy(HasCopy& cp);
 168 };
 169
 170 void has_trivial_default_constructor() {
 171   int t01[T(__has_trivial_constructor(Int))];
 172   int t02[T(__has_trivial_constructor(IntAr))];
 173   int t03[T(__has_trivial_constructor(Union))];
 174   int t04[T(__has_trivial_constructor(UnionAr))];
 175   int t05[T(__has_trivial_constructor(POD))];
 176   int t06[T(__has_trivial_constructor(Derives))];
 177   int t07[T(__has_trivial_constructor(ConstIntAr))];
 178   int t08[T(__has_trivial_constructor(ConstIntArAr))];
 179   int t09[T(__has_trivial_constructor(HasDest))];
 180   int t10[T(__has_trivial_constructor(HasPriv))];
 181   int t11[F(__has_trivial_constructor(HasCons))];
 182   int t12[F(__has_trivial_constructor(HasRef))];
 183   int t13[F(__has_trivial_constructor(HasCopy))];
 184   int t14[F(__has_trivial_constructor(IntRef))];
 185   int t15[T(__has_trivial_constructor(HasCopyAssign))];
 186   int t16[T(__has_trivial_constructor(const Int))];
 187   int t17[T(__has_trivial_constructor(NonPODAr))];
 188   int t18[F(__has_trivial_constructor(VirtAr))];
 189 }
 190
 191 void has_trivial_copy_constructor() {
 192   int t01[T(__has_trivial_copy(Int))];
 193   int t02[T(__has_trivial_copy(IntAr))];
 194   int t03[T(__has_trivial_copy(Union))];
 195   int t04[T(__has_trivial_copy(UnionAr))];
 196   int t05[T(__has_trivial_copy(POD))];
 197   int t06[T(__has_trivial_copy(Derives))];
 198   int t07[T(__has_trivial_copy(ConstIntAr))];
 199   int t08[T(__has_trivial_copy(ConstIntArAr))];
 200   int t09[T(__has_trivial_copy(HasDest))];
 201   int t10[T(__has_trivial_copy(HasPriv))];
 202   int t11[T(__has_trivial_copy(HasCons))];
 203   int t12[T(__has_trivial_copy(HasRef))];
 204   int t13[F(__has_trivial_copy(HasCopy))];
 205   int t14[T(__has_trivial_copy(IntRef))];
 206   int t15[T(__has_trivial_copy(HasCopyAssign))];
 207   int t16[T(__has_trivial_copy(const Int))];
 208   int t17[F(__has_trivial_copy(NonPODAr))];
 209   int t18[F(__has_trivial_copy(VirtAr))];
 210 }
 211
 212 void has_trivial_copy_assignment() {
 213   int t01[T(__has_trivial_assign(Int))];
 214   int t02[T(__has_trivial_assign(IntAr))];
 215   int t03[T(__has_trivial_assign(Union))];
 216   int t04[T(__has_trivial_assign(UnionAr))];
 217   int t05[T(__has_trivial_assign(POD))];
 218   int t06[T(__has_trivial_assign(Derives))];
 219   int t07[F(__has_trivial_assign(ConstIntAr))];
 220   int t08[F(__has_trivial_assign(ConstIntArAr))];
 221   int t09[T(__has_trivial_assign(HasDest))];
 222   int t10[T(__has_trivial_assign(HasPriv))];
 223   int t11[T(__has_trivial_assign(HasCons))];
 224   int t12[T(__has_trivial_assign(HasRef))];
 225   int t13[T(__has_trivial_assign(HasCopy))];
 226   int t14[F(__has_trivial_assign(IntRef))];
 227   int t15[F(__has_trivial_assign(HasCopyAssign))];
 228   int t16[F(__has_trivial_assign(const Int))];
 229   int t17[F(__has_trivial_assign(NonPODAr))];
 230   int t18[F(__has_trivial_assign(VirtAr))];
 231 }
 232
 233 void has_trivial_destructor() {
 234   int t01[T(__has_trivial_destructor(Int))];
 235   int t02[T(__has_trivial_destructor(IntAr))];
 236   int t03[T(__has_trivial_destructor(Union))];
 237   int t04[T(__has_trivial_destructor(UnionAr))];
 238   int t05[T(__has_trivial_destructor(POD))];
 239   int t06[T(__has_trivial_destructor(Derives))];
 240   int t07[T(__has_trivial_destructor(ConstIntAr))];
 241   int t08[T(__has_trivial_destructor(ConstIntArAr))];
 242   int t09[F(__has_trivial_destructor(HasDest))];
 243   int t10[T(__has_trivial_destructor(HasPriv))];
 244   int t11[T(__has_trivial_destructor(HasCons))];
 245   int t12[T(__has_trivial_destructor(HasRef))];
 246   int t13[T(__has_trivial_destructor(HasCopy))];
 247   int t14[T(__has_trivial_destructor(IntRef))];
 248   int t15[T(__has_trivial_destructor(HasCopyAssign))];
 249   int t16[T(__has_trivial_destructor(const Int))];
 250   int t17[T(__has_trivial_destructor(NonPODAr))];
 251   int t18[T(__has_trivial_destructor(VirtAr))];
 252 }
 253
 254 struct A { ~A() {} };
 255 template<typename> struct B : A { };
 256
 257 void f() {
 258   int t01[T(!__has_trivial_destructor(A))];
 259   int t02[T(!__has_trivial_destructor(B<int>))];
 260 }