clang/test/SemaTemplate/instantiate-expr-1.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s  -triple x86_64-pc-linux-gnu
   2 template<int I, int J>
   3 struct Bitfields {
   4   int simple : I; // expected-error{{bit-field 'simple' has zero width}}
   5   int parens : (J);
   6 };
   7
   8 void test_Bitfields(Bitfields<0, 5> *b) {
   9   (void)sizeof(Bitfields<10, 5>);
  10   (void)sizeof(Bitfields<0, 1>); // expected-note{{in instantiation of template class 'Bitfields<0, 1>' requested here}}
  11 }
  12
  13 template<int I, int J>
  14 struct BitfieldPlus {
  15   int bitfield : I + J; // expected-error{{bit-field 'bitfield' has zero width}}
  16 };
  17
  18 void test_BitfieldPlus() {
  19   (void)sizeof(BitfieldPlus<0, 1>);
  20   (void)sizeof(BitfieldPlus<-5, 5>); // expected-note{{in instantiation of template class 'BitfieldPlus<-5, 5>' requested here}}
  21 }
  22
  23 template<int I, int J>
  24 struct BitfieldMinus {
  25   int bitfield : I - J; // expected-error{{bit-field 'bitfield' has negative width (-1)}} \
  26   // expected-error{{bit-field 'bitfield' has zero width}}
  27 };
  28
  29 void test_BitfieldMinus() {
  30   (void)sizeof(BitfieldMinus<5, 1>);
  31   (void)sizeof(BitfieldMinus<0, 1>); // expected-note{{in instantiation of template class 'BitfieldMinus<0, 1>' requested here}}
  32   (void)sizeof(BitfieldMinus<5, 5>); // expected-note{{in instantiation of template class 'BitfieldMinus<5, 5>' requested here}}
  33 }
  34
  35 template<int I, int J>
  36 struct BitfieldDivide {
  37   int bitfield : I / J; // expected-error{{expression is not an integral constant expression}} \
  38                         // expected-note{{division by zero}}
  39 };
  40
  41 void test_BitfieldDivide() {
  42   (void)sizeof(BitfieldDivide<5, 1>);
  43   (void)sizeof(BitfieldDivide<5, 0>); // expected-note{{in instantiation of template class 'BitfieldDivide<5, 0>' requested here}}
  44 }
  45
  46 template<typename T, T I, int J>
  47 struct BitfieldDep {
  48   int bitfield : I + J;
  49 };
  50
  51 void test_BitfieldDep() {
  52   (void)sizeof(BitfieldDep<int, 1, 5>);
  53 }
  54
  55 template<int I>
  56 struct BitfieldNeg {
  57   int bitfield : (-I); // expected-error{{bit-field 'bitfield' has negative width (-5)}}
  58 };
  59
  60 template<typename T, T I>
  61 struct BitfieldNeg2 {
  62   int bitfield : (-I); // expected-error{{bit-field 'bitfield' has negative width (-5)}}
  63 };
  64
  65 void test_BitfieldNeg() {
  66   (void)sizeof(BitfieldNeg<-5>); // okay
  67   (void)sizeof(BitfieldNeg<5>); // expected-note{{in instantiation of template class 'BitfieldNeg<5>' requested here}}
  68   (void)sizeof(BitfieldNeg2<int, -5>); // okay
  69   (void)sizeof(BitfieldNeg2<int, 5>); // expected-note{{in instantiation of template class 'BitfieldNeg2<int, 5>' requested here}}
  70 }
  71
  72 template<typename T>
  73 void increment(T &x) {
  74   (void)++x;
  75 }
  76
  77 struct Incrementable {
  78   Incrementable &operator++();
  79 };
  80
  81 void test_increment(Incrementable inc) {
  82   increment(inc);
  83 }
  84
  85 template<typename T>
  86 void add(const T &x) {
  87   (void)(x + x);
  88 }
  89
  90 namespace PR6237 {
  91   template <typename T>
  92   void f(T t) {
  93     t++;
  94   }
  95
  96   struct B { };
  97   B operator++(B &, int);
  98
  99   template void f(B);
 100 }
 101
 102 struct Addable {
 103   Addable operator+(const Addable&) const;
 104 };
 105
 106 void test_add(Addable &a) {
 107   add(a);
 108 }
 109
 110 struct CallOperator {
 111   int &operator()(int);
 112   double &operator()(double);
 113 };
 114
 115 template<typename Result, typename F, typename Arg1>
 116 Result test_call_operator(F f, Arg1 arg1) {
 117   // PR5266: non-dependent invocations of a function call operator.
 118   CallOperator call_op;
 119   int &ir = call_op(17);
 120   return f(arg1);
 121 }
 122
 123 void test_call_operator(CallOperator call_op, int i, double d) {
 124   int &ir = test_call_operator<int&>(call_op, i);
 125   double &dr = test_call_operator<double&>(call_op, d);
 126 }
 127
 128 template<typename T>
 129 void test_asm(T t) {
 130   asm ("nop" : "=r"(*t) : "r"(*t)); // expected-error {{indirection requires pointer operand ('int' invalid)}}
 131 }
 132
 133 void test_asm() {
 134   int* a;
 135   test_asm(a);
 136
 137   int b;
 138   test_asm(b); // expected-note {{in instantiation of function template specialization 'test_asm<int>' requested here}}
 139 }
 140
 141 namespace PR6424 {
 142   template<int I> struct X {
 143     X() {
 144       int *ip = I; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
 145     }
 146   };
 147
 148   template<int> struct Y {
 149     typedef X<7> X7;
 150
 151     void f() { X7(); } // expected-note{{instantiation}}
 152   };
 153
 154   template void Y<3>::f();
 155
 156   template<int I>
 157   struct X2 {
 158     void *operator new(__SIZE_TYPE__) {
 159       int *ip = I; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
 160       return ip;
 161     }
 162   };
 163
 164   template<int> struct Y2 {
 165     typedef X2<7> X;
 166     void f() {
 167       new X(); // expected-note{{instantiation of}}
 168     }
 169   };
 170
 171   template void Y2<3>::f();
 172
 173   template<typename T>
 174   void rdar10283928(int count) {
 175     (void)new char[count]();
 176   }
 177
 178   template void rdar10283928<int>(int);
 179 }
 180
 181 namespace PR10864 {
 182   template<typename T> class Vals {};
 183   template<> class Vals<int> { public: static const int i = 1; };
 184   template<> class Vals<float> { public: static const double i; };
 185   template<typename T> void test_asm_tied(T o) {
 186     __asm("addl $1, %0" : "=r" (o) : "0"(Vals<T>::i)); // expected-error {{input with type 'double' matching output with type 'float'}}
 187   }
 188   void test_asm_tied() {
 189     test_asm_tied(1);
 190     test_asm_tied(1.f); // expected-note {{instantiation of}}
 191   }
 192 }
 193
 194 namespace TestAsmCleanup {
 195 struct S {
 196   operator int() const { return 1; }
 197   ~S();
 198 };
 199
 200 template <class T>
 201 void foo() {
 202   __asm__ __volatile__("%[i]"
 203                        :
 204                        : [i] "r"(-S()));
 205 }
 206
 207 void test() { foo<void>(); }
 208 } // namespace TestAsmCleanup