334 lines · cpp
1// RUN: %clang_cc1 -fsyntax-only -verify %s2// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s3// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s4 5template<typename T>6class C { C(int a0 = 0); };7 8template<>9C<char>::C(int a0);10 11struct S { }; // expected-note 3 {{candidate constructor (the implicit copy constructor)}}12#if __cplusplus >= 201103L // C++11 or later13// expected-note@-2 3 {{candidate constructor (the implicit move constructor) not viable}}14#endif15 16template<typename T> void f1(T a, T b = 10) { } // expected-error{{no viable conversion}} \17// expected-note{{passing argument to parameter 'b' here}}18 19template<typename T> void f2(T a, T b = T()) { }20 21template<typename T> void f3(T a, T b = T() + T()); // expected-error{{invalid operands to binary expression ('S' and 'S')}}22 23void g() {24 f1(10);25 f1(S()); // expected-note{{in instantiation of default function argument expression for 'f1<S>' required here}}26 27 f2(10);28 f2(S());29 30 f3(10);31 f3(S()); // expected-note{{in instantiation of default function argument expression for 'f3<S>' required here}}32}33 34template<typename T> struct F {35 F(T t = 10); // expected-error{{no viable conversion}} \36 // expected-note{{passing argument to parameter 't' here}}37 void f(T t = 10); // expected-error{{no viable conversion}} \38 // expected-note{{passing argument to parameter 't' here}}39};40 41struct FD : F<int> { };42 43void g2() {44 F<int> f;45 FD fd;46}47 48void g3(F<int> f, F<struct S> s) {49 f.f();50 s.f(); // expected-note{{in instantiation of default function argument expression for 'f<S>' required here}}51 52 F<int> f2;53 F<S> s2; // expected-note{{in instantiation of default function argument expression for 'F<S>' required here}}54}55 56template<typename T> struct G {57 G(T) {}58};59 60void s(G<int> flags = 10) { }61 62// Test default arguments63template<typename T>64struct X0 {65 void f(T = T()); // expected-error{{no matching}}66};67 68template<typename U>69void X0<U>::f(U) { }70 71void test_x0(X0<int> xi) {72 xi.f();73 xi.f(17);74}75 76struct NotDefaultConstructible { // expected-note 2 {{candidate constructor (the implicit copy constructor) not viable}}77#if __cplusplus >= 201103L // C++11 or later78// expected-note@-2 2 {{candidate constructor (the implicit move constructor) not viable}}79#endif80 NotDefaultConstructible(int); // expected-note 2{{candidate}}81};82 83void test_x0_not_default_constructible(X0<NotDefaultConstructible> xn) {84 xn.f(NotDefaultConstructible(17));85 xn.f(42);86 xn.f(); // expected-note{{in instantiation of default function argument}}87}88 89template<typename T>90struct X1 {91 typedef T value_type;92 X1(const value_type& value = value_type());93};94 95void test_X1() {96 X1<int> x1;97}98 99template<typename T>100struct X2 {101 void operator()(T = T()); // expected-error{{no matching}}102};103 104void test_x2(X2<int> x2i, X2<NotDefaultConstructible> x2n) {105 x2i();106 x2i(17);107 x2n(NotDefaultConstructible(17));108 x2n(); // expected-note{{in instantiation of default function argument}}109}110 111// PR5283112namespace PR5283 {113template<typename T> struct A {114 A(T = 1); // expected-error 3 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'int'}} \115 // expected-note 3{{passing argument to parameter here}}116};117 118struct B : A<int*> { 119 B();120};121B::B() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}122 123struct C : virtual A<int*> {124 C();125};126C::C() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}127 128struct D {129 D();130 131 A<int*> a;132};133D::D() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}134}135 136// PR5301137namespace pr5301 {138 void f(int, int = 0);139 140 template <typename T>141 void g(T, T = 0);142 143 template <int I>144 void i(int a = I);145 146 template <typename T>147 void h(T t) {148 f(0);149 g(1);150 g(t);151 i<2>();152 }153 154 void test() {155 h(0);156 }157}158 159// PR5810160namespace PR5810 {161 template<typename T>162 struct allocator {163 allocator() { int a[sizeof(T) ? -1 : -1]; } // expected-error2 {{array with a negative size}}164 };165 166 template<typename T>167 struct vector {168 vector(const allocator<T>& = allocator<T>()) {} // expected-note2 {{instantiation of}}169 };170 171 struct A { };172 struct B { };173 174 template<typename>175 void FilterVTs() {176 vector<A> Result;177 }178 179 void f() {180 vector<A> Result;181 }182 183 template<typename T>184 struct X {185 vector<B> bs;186 X() { }187 };188 189 void f2() {190 X<float> x; // expected-note{{member function}}191 }192}193 194template<typename T> void f4(T, int = 17);195template<> void f4<int>(int, int);196 197void f4_test(int i) {198 f4(i);199}200 201// Instantiate for initialization202namespace InstForInit {203 template<typename T>204 struct Ptr {205 typedef T* type;206 Ptr(type);207 };208 209 template<typename T>210 struct Holder {211 Holder(int i, Ptr<T> ptr = 0);212 };213 214 void test_holder(int i) {215 Holder<int> h(i);216 }217};218 219namespace PR5810b {220 template<typename T>221 T broken() {222 T t;223 double**** not_it = t;224 }225 226 void f(int = broken<int>());227 void g() { f(17); }228}229 230namespace PR5810c {231 template<typename T>232 struct X { 233 X() { 234 T t;235 double *****p = t; // expected-error{{cannot initialize a variable of type 'double *****' with an lvalue of type 'int'}}236 }237 X(const X&) { }238 };239 240 struct Y : X<int> { // expected-note{{instantiation of}}241 };242 243 void f(Y y = Y());244 245 void g() { f(); }246}247 248namespace PR8127 {249 template< typename T > class PointerClass {250 public:251 PointerClass( T * object_p ) : p_( object_p ) {252 p_->acquire();253 }254 private: 255 T * p_;256 };257 258 class ExternallyImplementedClass;259 260 class MyClass {261 void foo( PointerClass<ExternallyImplementedClass> = 0 );262 };263}264 265namespace rdar8427926 {266 template<typename T>267 struct Boom {268 ~Boom() {269 T t;270 double *******ptr = t; // expected-error 2{{cannot initialize}}271 }272 };273 274 Boom<float> *bfp;275 276 struct X {277 void f(Boom<int> = Boom<int>()) { } // expected-note{{requested here}}278 void g(int x = (delete bfp, 0)); // expected-note{{requested here}}279 };280 281 void test(X *x) {282 x->f();283 x->g();284 }285}286 287namespace PR8401 {288 template<typename T> 289 struct A { 290 A() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}291 };292 293 template<typename T>294 struct B {295 B(const A<T>& a = A<T>()); // expected-note{{in instantiation of}}296 };297 298 void f(B<int> b = B<int>());299 300 void g() {301 f();302 }303}304 305namespace PR12581 {306 const int a = 0;307 template < typename > struct A;308 template < typename MatrixType, int =309 A < MatrixType >::Flags ? : A < MatrixType >::Flags & a > class B;310 void311 fn1 ()312 {313 }314}315 316namespace PR13758 {317 template <typename T> struct move_from {318 T invalid;319 };320 template <class K>321 struct unordered_map {322 explicit unordered_map(int n = 42);323 unordered_map(move_from<K> other);324 };325 template<typename T>326 void StripedHashTable() {327 new unordered_map<void>();328 new unordered_map<void>;329 }330 void tt() {331 StripedHashTable<int>();332 }333}334