1 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
2
3 // If a friend function is defined in several non-template classes,
4 // it is an error.
5
6 void func1(int);
7 struct C1a {
func1(int)8 friend void func1(int) {} // expected-note{{previous definition is here}}
9 };
10 struct C1b {
func1(int)11 friend void func1(int) {} // expected-error{{redefinition of 'func1'}}
12 };
13
14
15 // If a friend function is defined in both non-template and template
16 // classes it is an error only if the template is instantiated.
17
18 void func2(int);
19 struct C2a {
func2(int)20 friend void func2(int) {}
21 };
22 template<typename T> struct C2b {
func2(int)23 friend void func2(int) {}
24 };
25
26 void func3(int);
27 struct C3a {
func3(int)28 friend void func3(int) {} // expected-note{{previous definition is here}}
29 };
30 template<typename T> struct C3b {
func3(int)31 friend void func3(int) {} // expected-error{{redefinition of 'func3'}}
32 };
33 C3b<long> c3; // expected-note{{in instantiation of template class 'C3b<long>' requested here}}
34
35
36 // If a friend function is defined in several template classes it is an error
37 // only if several templates are instantiated.
38
39 void func4(int);
40 template<typename T> struct C4a {
func4(int)41 friend void func4(int) {}
42 };
43 template<typename T> struct C4b {
func4(int)44 friend void func4(int) {}
45 };
46
47
48 void func5(int);
49 template<typename T> struct C5a {
func5(int)50 friend void func5(int) {}
51 };
52 template<typename T> struct C5b {
func5(int)53 friend void func5(int) {}
54 };
55 C5a<long> c5a;
56
57 void func6(int);
58 template<typename T> struct C6a {
func6(int)59 friend void func6(int) {} // expected-note{{previous definition is here}}
60 };
61 template<typename T> struct C6b {
func6(int)62 friend void func6(int) {} // expected-error{{redefinition of 'func6'}}
63 };
64 C6a<long> c6a;
65 C6b<int*> c6b; // expected-note{{in instantiation of template class 'C6b<int *>' requested here}}
66
67 void func7(int);
68 template<typename T> struct C7 {
func7(int)69 friend void func7(int) {} // expected-error{{redefinition of 'func7'}}
70 // expected-note@-1{{previous definition is here}}
71 };
72 C7<long> c7a;
73 C7<int*> c7b; // expected-note{{in instantiation of template class 'C7<int *>' requested here}}
74
75
76 // Even if clases are not instantiated and hence friend functions defined in them are not
77 // available, their declarations can be checked.
78
79 void func8(int); // expected-note{{previous declaration is here}}
80 template<typename T> struct C8a {
81 friend long func8(int); // expected-error{{functions that differ only in their return type cannot be overloaded}}
82 };
83
84 void func9(int); // expected-note{{previous declaration is here}}
85 template<typename T> struct C9a {
86 friend int func9(int); // expected-error{{functions that differ only in their return type cannot be overloaded}}
87 };
88
89 void func10(int); // expected-note{{previous declaration is here}}
90 template<typename T> struct C10a {
91 friend int func10(int); // expected-error{{functions that differ only in their return type cannot be overloaded}}
92 };
93
94 void func_11(); // expected-note{{previous declaration is here}}
95 template<typename T> class C11 {
96 friend int func_11(); // expected-error{{functions that differ only in their return type cannot be overloaded}}
97 };
98
99 void func_12(int x); // expected-note{{previous declaration is here}}
100 template<typename T> class C12 {
101 friend void func_12(int x = 0); // expected-error{{friend declaration specifying a default argument must be the only declaration}}
102 };
103
104 // Friend function with uninstantiated body is still a definition.
105
106 template<typename T> struct C20 {
func_20()107 friend void func_20() {} // expected-note{{previous definition is here}}
108 };
109 C20<int> c20i;
func_20()110 void func_20() {} // expected-error{{redefinition of 'func_20'}}
111
112 template<typename T> struct C21a {
func_21()113 friend void func_21() {} // expected-note{{previous definition is here}}
114 };
115 template<typename T> struct C21b {
func_21()116 friend void func_21() {} // expected-error{{redefinition of 'func_21'}}
117 };
118 C21a<int> c21ai;
119 C21b<int> c21bi; // expected-note{{in instantiation of template class 'C21b<int>' requested here}}
120
121 template<typename T> struct C22a {
func_22()122 friend void func_22() {} // expected-note{{previous definition is here}}
123 };
124 template<typename T> struct C22b {
125 friend void func_22();
126 };
127 C22a<int> c22ai;
128 C22b<int> c22bi;
func_22()129 void func_22() {} // expected-error{{redefinition of 'func_22'}}
130
131
132 // Case of template friend functions.
133
134 template<typename T> void func_31(T *x);
135 template<typename T1>
136 struct C31a {
func_31(T * x)137 template<typename T> friend void func_31(T *x) {}
138 };
139 template<typename T1>
140 struct C31b {
func_31(T * x)141 template<typename T> friend void func_31(T *x) {}
142 };
143
144
func_32(T * x)145 template<typename T> inline void func_32(T *x) {}
146 template<typename T1>
147 struct C32a {
func_32(T * x)148 template<typename T> friend void func_32(T *x) {}
149 };
150 template<typename T1>
151 struct C32b {
func_32(T * x)152 template<typename T> friend void func_32(T *x) {}
153 };
154
155
156 template<typename T1>
157 struct C33a {
func_33(T * x)158 template<typename T> friend void func_33(T *x) {}
159 };
160 template<typename T1>
161 struct C33b {
func_33(T * x)162 template<typename T> friend void func_33(T *x) {}
163 };
164
165
func_34(T * x)166 template<typename T> inline void func_34(T *x) {} // expected-note{{previous definition is here}}
167 template<typename T1>
168 struct C34 {
func_34(T * x)169 template<typename T> friend void func_34(T *x) {} // expected-error{{redefinition of 'func_34'}}
170 };
171
172 C34<int> v34; // expected-note{{in instantiation of template class 'C34<int>' requested here}}
173
174
175 template<typename T> inline void func_35(T *x);
176 template<typename T1>
177 struct C35a {
func_35(T * x)178 template<typename T> friend void func_35(T *x) {} // expected-note{{previous definition is here}}
179 };
180 template<typename T1>
181 struct C35b {
func_35(T * x)182 template<typename T> friend void func_35(T *x) {} // expected-error{{redefinition of 'func_35'}}
183 };
184
185 C35a<int> v35a;
186 C35b<int> v35b; // expected-note{{in instantiation of template class 'C35b<int>' requested here}}
187
188
189 template<typename T> void func_36(T *x);
190 template<typename T1>
191 struct C36 {
func_36(T * x)192 template<typename T> friend void func_36(T *x) {} // expected-error{{redefinition of 'func_36'}}
193 // expected-note@-1{{previous definition is here}}
194 };
195
196 C36<int> v36a;
197 C36<long> v36b; //expected-note{{in instantiation of template class 'C36<long>' requested here}}
198
199
200 template<typename T> void func_37(T *x);
201 template<typename T1>
202 struct C37 {
func_37(T * x)203 template<typename T> friend void func_37(T *x) {} // expected-note{{previous definition is here}}
204 };
205
206 C37<int> v37;
func_37(T * x)207 template<typename T> void func_37(T *x) {} // expected-error{{redefinition of 'func_37'}}
208
209
210 namespace pr22307 {
211
212 struct t {
213 friend int leak(t);
214 };
215
216 template<typename v>
217 struct m {
leak(t)218 friend int leak(t) { return sizeof(v); } // expected-error{{redefinition of 'leak'}} expected-note{{previous definition is here}}
219 };
220
221 template struct m<char>;
222 template struct m<short>; // expected-note{{in instantiation of template class 'pr22307::m<short>' requested here}}
223
main()224 int main() {
225 leak(t());
226 }
227
228 }
229
230 namespace pr17923 {
231
232 void f(unsigned long long);
233
234 template<typename T> struct X {
f(unsigned long long)235 friend void f(unsigned long long) {
236 T t;
237 }
238 };
239
main()240 int main() { f(1234); }
241
242 }
243
244 namespace pr17923a {
245
246 int get();
247
248 template< int value >
249 class set {
get()250 friend int get()
251 { return value; } // return 0; is OK
252 };
253
254 template class set< 5 >;
255
main()256 int main() {
257 get();
258 }
259
260 }
261
262 namespace pr8035 {
263
264 void Function();
265
main(int argc,char * argv[])266 int main(int argc, char* argv[]) {
267 Function();
268 }
269
270 template <typename T>
271 struct Test {
Function()272 friend void Function() { }
273 };
274
275 template class Test<int>;
276
277 }
278
279 namespace pr14785 {
280 template<typename T>
281 struct Somewhat {
internalpr14785::Somewhat282 void internal() const { }
operator +(int const &,Somewhat<T> const &)283 friend void operator+(int const &, Somewhat<T> const &) {} // expected-error{{redefinition of 'operator+'}}
284 };
285
operator +(int const &,Somewhat<char> const & x)286 void operator+(int const &, Somewhat<char> const &x) { // expected-note {{previous definition is here}}
287 x.internal(); // expected-note{{in instantiation of template class 'pr14785::Somewhat<char>' requested here}}
288 }
289 }
290
291 namespace D30375 {
292 template <typename K> struct B {
293 template <typename A> bool insert(A &);
294 };
295
296 template <typename K>
insert(A & x)297 template <typename A> bool B<K>::insert(A &x) { return x < x; }
298
299 template <typename K> class D {
300 B<K> t;
301
302 public:
303 K x;
insert()304 bool insert() { return t.insert(x); }
305 template <typename K1> friend bool operator<(const D<K1> &, const D<K1> &);
306 };
307
308 template <typename K> bool operator<(const D<K> &, const D<K> &);
309
func()310 void func() {
311 D<D<int>> cache;
312 cache.insert();
313 }
314 }
315
316 namespace PR39742 {
317 template<typename>
318 struct wrapper {
319 template<typename>
friend_function_template()320 friend void friend_function_template() {} // expected-error{{redefinition of 'friend_function_template'}}
321 // expected-note@-1{{previous definition is here}}
322 };
323
324 wrapper<bool> x;
325 wrapper<int> y; // expected-note{{in instantiation of template class 'PR39742::wrapper<int>' requested here}}
326 }
327