1 // RUN: %clang_cc1 -fsyntax-only -verify %s 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 'struct 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 'struct 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 'struct BitfieldMinus<0, 1>' requested here}} 32 (void)sizeof(BitfieldMinus<5, 5>); // expected-note{{in instantiation of template class 'struct 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 integer constant expression}} \ 38 // expected-note{{division by zero}} \ 39 // expected-warning {{division by zero is undefined}} 40 }; 41 42 void test_BitfieldDivide() { 43 (void)sizeof(BitfieldDivide<5, 1>); 44 (void)sizeof(BitfieldDivide<5, 0>); // expected-note{{in instantiation of template class 'struct BitfieldDivide<5, 0>' requested here}} 45 } 46 47 template<typename T, T I, int J> 48 struct BitfieldDep { 49 int bitfield : I + J; 50 }; 51 52 void test_BitfieldDep() { 53 (void)sizeof(BitfieldDep<int, 1, 5>); 54 } 55 56 template<int I> 57 struct BitfieldNeg { 58 int bitfield : (-I); // expected-error{{bit-field 'bitfield' has negative width (-5)}} 59 }; 60 61 template<typename T, T I> 62 struct BitfieldNeg2 { 63 int bitfield : (-I); // expected-error{{bit-field 'bitfield' has negative width (-5)}} 64 }; 65 66 void test_BitfieldNeg() { 67 (void)sizeof(BitfieldNeg<-5>); // okay 68 (void)sizeof(BitfieldNeg<5>); // expected-note{{in instantiation of template class 'struct BitfieldNeg<5>' requested here}} 69 (void)sizeof(BitfieldNeg2<int, -5>); // okay 70 (void)sizeof(BitfieldNeg2<int, 5>); // expected-note{{in instantiation of template class 'struct BitfieldNeg2<int, 5>' requested here}} 71 } 72 73 template<typename T> 74 void increment(T &x) { 75 (void)++x; 76 } 77 78 struct Incrementable { 79 Incrementable &operator++(); 80 }; 81 82 void test_increment(Incrementable inc) { 83 increment(inc); 84 } 85 86 template<typename T> 87 void add(const T &x) { 88 (void)(x + x); 89 } 90 91 struct Addable { 92 Addable operator+(const Addable&) const; 93 }; 94 95 void test_add(Addable &a) { 96 add(a); 97 } 98 99 struct CallOperator { 100 int &operator()(int); 101 double &operator()(double); 102 }; 103 104 template<typename Result, typename F, typename Arg1> 105 Result test_call_operator(F f, Arg1 arg1) { 106 // PR5266: non-dependent invocations of a function call operator. 107 CallOperator call_op; 108 int &ir = call_op(17); 109 return f(arg1); 110 } 111 112 void test_call_operator(CallOperator call_op, int i, double d) { 113 int &ir = test_call_operator<int&>(call_op, i); 114 double &dr = test_call_operator<double&>(call_op, d); 115 } 116