1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 struct X0 { // expected-note{{candidate}}
3 X0(int); // expected-note{{candidate}}
4 template<typename T> X0(T); // expected-note {{candidate}}
5 template<typename T, typename U> X0(T*, U*); // expected-note {{candidate}}
6
7 // PR4761
X0X08 template<typename T> X0() : f0(T::foo) {} // expected-note {{candidate}}
9 int f0;
10 };
11
12 void accept_X0(X0);
13
test_X0(int i,float f)14 void test_X0(int i, float f) {
15 X0 x0a(i);
16 X0 x0b(f);
17 X0 x0c = i;
18 X0 x0d = f;
19 accept_X0(i);
20 accept_X0(&i);
21 accept_X0(f);
22 accept_X0(&f);
23 X0 x0e(&i, &f);
24 X0 x0f(&f, &i);
25
26 X0 x0g(f, &i); // expected-error{{no matching constructor}}
27 }
28
29 template<typename T>
30 struct X1 {
31 X1(const X1&);
32 template<typename U> X1(const X1<U>&);
33 };
34
35 template<typename T>
36 struct Outer {
37 typedef X1<T> A;
38
39 A alloc;
40
OuterOuter41 explicit Outer(const A& a) : alloc(a) { }
42 };
43
test_X1(X1<int> xi)44 void test_X1(X1<int> xi) {
45 Outer<int> oi(xi);
46 Outer<float> of(xi);
47 }
48
49 // PR4655
50 template<class C> struct A {};
51 template <> struct A<int>{A(const A<int>&);};
BB52 struct B { A<int> x; B(B& a) : x(a.x) {} };
53
54 struct X2 {
55 X2(); // expected-note{{candidate constructor}}
56 X2(X2&); // expected-note {{candidate constructor}}
57 template<typename T> X2(T); // expected-note {{candidate template ignored: instantiation would take its own class type by value}}
58 };
59
test(bool Cond,X2 x2)60 X2 test(bool Cond, X2 x2) {
61 if (Cond)
62 return x2; // okay, uses copy constructor
63
64 return X2(); // expected-error{{no matching constructor}}
65 }
66
67 struct X3 {
68 template<typename T> X3(T);
69 };
70
71 template<> X3::X3(X3); // expected-error{{must pass its first argument by reference}}
72
73 struct X4 {
74 X4();
75 ~X4();
76 X4(X4&);
77 template<typename T> X4(const T&, int = 17);
78 };
79
test_X4(bool Cond,X4 x4)80 X4 test_X4(bool Cond, X4 x4) {
81 X4 a(x4, 17); // okay, constructor template
82 X4 b(x4); // okay, copy constructor
83 return X4();
84 }
85
86 // Instantiation of a non-dependent use of a constructor
87 struct DefaultCtorHasDefaultArg {
88 explicit DefaultCtorHasDefaultArg(int i = 17);
89 };
90
91 template<typename T>
default_ctor_inst()92 void default_ctor_inst() {
93 DefaultCtorHasDefaultArg def;
94 }
95
96 template void default_ctor_inst<int>();
97
98 template<typename T>
99 struct X5 {
100 X5();
101 X5(const T &);
102 };
103
104 struct X6 {
105 template<typename T> X6(T);
106 };
107
test_X5_X6()108 void test_X5_X6() {
109 X5<X6> tf;
110 X5<X6> tf2(tf);
111 }
112
113 namespace PR8182 {
114 struct foo {
115 foo();
116 template<class T> foo(T&);
117
118 private:
119 foo(const foo&);
120 };
121
test_foo()122 void test_foo() {
123 foo f1;
124 foo f2(f1);
125 foo f3 = f1;
126 }
127
128 }
129
130 // Don't blow out the stack trying to call an illegal constructor
131 // instantiation. We intentionally allow implicit instantiations to
132 // exist, so make sure they're unusable.
133 //
134 // rdar://19199836
135 namespace self_by_value {
136 template <class T, class U> struct A {
Aself_by_value::A137 A() {}
Aself_by_value::A138 A(const A<T,U> &o) {}
Aself_by_value::A139 A(A<T,T> o) {}
140 };
141
142 void helper(A<int,float>);
143
test1(A<int,int> a)144 void test1(A<int,int> a) {
145 helper(a);
146 }
test2()147 void test2() {
148 helper(A<int,int>());
149 }
150 }
151
152 namespace self_by_value_2 {
153 template <class T, class U> struct A {
Aself_by_value_2::A154 A() {} // expected-note {{not viable: requires 0 arguments}}
Aself_by_value_2::A155 A(A<T,U> &o) {} // expected-note {{not viable: expects an l-value}}
Aself_by_value_2::A156 A(A<T,T> o) {} // expected-note {{ignored: instantiation takes its own class type by value}}
157 };
158
159 void helper_A(A<int,int>); // expected-note {{passing argument to parameter here}}
test_A()160 void test_A() {
161 helper_A(A<int,int>()); // expected-error {{no matching constructor}}
162 }
163 }
164
165 namespace self_by_value_3 {
166 template <class T, class U> struct A {
Aself_by_value_3::A167 A() {}
Aself_by_value_3::A168 A(A<T,U> &o) {}
Aself_by_value_3::A169 A(A<T,T> o) {}
170 };
171
172 void helper_A(A<int,int>);
test_A(A<int,int> b)173 void test_A(A<int,int> b) {
174 helper_A(b);
175 }
176 }
177