1 | /* Help friends in C++. |
2 | Copyright (C) 1997-2024 Free Software Foundation, Inc. |
3 | |
4 | This file is part of GCC. |
5 | |
6 | GCC is free software; you can redistribute it and/or modify |
7 | it under the terms of the GNU General Public License as published by |
8 | the Free Software Foundation; either version 3, or (at your option) |
9 | any later version. |
10 | |
11 | GCC is distributed in the hope that it will be useful, |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | GNU General Public License for more details. |
15 | |
16 | You should have received a copy of the GNU General Public License |
17 | along with GCC; see the file COPYING3. If not see |
18 | <http://www.gnu.org/licenses/>. */ |
19 | |
20 | #include "config.h" |
21 | #include "system.h" |
22 | #include "coretypes.h" |
23 | #include "cp-tree.h" |
24 | |
25 | /* Friend data structures are described in cp-tree.h. */ |
26 | |
27 | |
28 | /* The GLOBAL_FRIEND scope (functions, classes, or templates) is |
29 | regarded as a friend of every class. This is only used by libcc1, |
30 | to enable GDB's code snippets to access private members without |
31 | disabling access control in general, which could cause different |
32 | template overload resolution results when accessibility matters |
33 | (e.g. tests for an accessible member). */ |
34 | |
35 | static GTY(()) tree global_friend; |
36 | |
37 | /* Set the GLOBAL_FRIEND for this compilation session. It might be |
38 | set multiple times, but always to the same scope. */ |
39 | |
40 | void |
41 | set_global_friend (tree scope) |
42 | { |
43 | gcc_checking_assert (scope != NULL_TREE); |
44 | gcc_assert (!global_friend || global_friend == scope); |
45 | global_friend = scope; |
46 | } |
47 | |
48 | /* Return TRUE if SCOPE is the global friend. */ |
49 | |
50 | bool |
51 | is_global_friend (tree scope) |
52 | { |
53 | gcc_checking_assert (scope != NULL_TREE); |
54 | |
55 | if (global_friend == scope) |
56 | return true; |
57 | |
58 | if (!global_friend) |
59 | return false; |
60 | |
61 | if (is_specialization_of_friend (global_friend, scope)) |
62 | return true; |
63 | |
64 | return false; |
65 | } |
66 | |
67 | /* Returns nonzero if SUPPLICANT is a friend of TYPE. */ |
68 | |
69 | int |
70 | is_friend (tree type, tree supplicant) |
71 | { |
72 | int declp; |
73 | tree list; |
74 | tree context; |
75 | |
76 | if (supplicant == NULL_TREE || type == NULL_TREE) |
77 | return 0; |
78 | |
79 | if (is_global_friend (scope: supplicant)) |
80 | return 1; |
81 | |
82 | declp = DECL_P (supplicant); |
83 | |
84 | if (declp) |
85 | /* It's a function decl. */ |
86 | { |
87 | tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); |
88 | tree name = DECL_NAME (supplicant); |
89 | |
90 | for (; list ; list = TREE_CHAIN (list)) |
91 | { |
92 | if (name == FRIEND_NAME (list)) |
93 | { |
94 | tree friends = FRIEND_DECLS (list); |
95 | for (; friends ; friends = TREE_CHAIN (friends)) |
96 | { |
97 | tree this_friend = TREE_VALUE (friends); |
98 | |
99 | if (this_friend == NULL_TREE) |
100 | continue; |
101 | |
102 | if (supplicant == this_friend) |
103 | return 1; |
104 | |
105 | if (is_specialization_of_friend (supplicant, this_friend)) |
106 | return 1; |
107 | } |
108 | break; |
109 | } |
110 | } |
111 | } |
112 | else |
113 | /* It's a type. */ |
114 | { |
115 | if (same_type_p (supplicant, type)) |
116 | return 1; |
117 | |
118 | list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type))); |
119 | for (; list ; list = TREE_CHAIN (list)) |
120 | { |
121 | tree t = TREE_VALUE (list); |
122 | |
123 | if (TREE_CODE (t) == TEMPLATE_DECL ? |
124 | is_specialization_of_friend (TYPE_MAIN_DECL (supplicant), t) : |
125 | same_type_p (supplicant, t)) |
126 | return 1; |
127 | } |
128 | } |
129 | |
130 | if (declp) |
131 | { |
132 | if (DECL_FUNCTION_MEMBER_P (supplicant)) |
133 | context = DECL_CONTEXT (supplicant); |
134 | else if (tree fc = DECL_FRIEND_CONTEXT (supplicant)) |
135 | context = fc; |
136 | else |
137 | context = NULL_TREE; |
138 | } |
139 | else |
140 | { |
141 | if (TYPE_CLASS_SCOPE_P (supplicant)) |
142 | /* Nested classes get the same access as their enclosing types, as |
143 | per DR 45 (this is a change from the standard). */ |
144 | context = TYPE_CONTEXT (supplicant); |
145 | else |
146 | /* Local classes have the same access as the enclosing function. */ |
147 | context = decl_function_context (TYPE_MAIN_DECL (supplicant)); |
148 | } |
149 | |
150 | /* A namespace is not friend to anybody. */ |
151 | if (context && TREE_CODE (context) == NAMESPACE_DECL) |
152 | context = NULL_TREE; |
153 | |
154 | if (context) |
155 | return is_friend (type, supplicant: context); |
156 | |
157 | return 0; |
158 | } |
159 | |
160 | /* Add a new friend to the friends of the aggregate type TYPE. |
161 | DECL is the FUNCTION_DECL of the friend being added. |
162 | |
163 | If COMPLAIN is true, warning about duplicate friend is issued. |
164 | We want to have this diagnostics during parsing but not |
165 | when a template is being instantiated. */ |
166 | |
167 | void |
168 | add_friend (tree type, tree decl, bool complain) |
169 | { |
170 | tree typedecl; |
171 | tree list; |
172 | tree name; |
173 | tree ctx; |
174 | |
175 | if (decl == error_mark_node) |
176 | return; |
177 | |
178 | typedecl = TYPE_MAIN_DECL (type); |
179 | list = DECL_FRIENDLIST (typedecl); |
180 | name = DECL_NAME (decl); |
181 | type = TREE_TYPE (typedecl); |
182 | |
183 | while (list) |
184 | { |
185 | if (name == FRIEND_NAME (list)) |
186 | { |
187 | tree friends = FRIEND_DECLS (list); |
188 | for (; friends ; friends = TREE_CHAIN (friends)) |
189 | { |
190 | if (decl == TREE_VALUE (friends)) |
191 | { |
192 | if (complain) |
193 | warning (OPT_Wredundant_decls, |
194 | "%qD is already a friend of class %qT" , |
195 | decl, type); |
196 | return; |
197 | } |
198 | } |
199 | |
200 | TREE_VALUE (list) = tree_cons (NULL_TREE, decl, |
201 | TREE_VALUE (list)); |
202 | break; |
203 | } |
204 | list = TREE_CHAIN (list); |
205 | } |
206 | |
207 | ctx = DECL_CONTEXT (decl); |
208 | if (ctx && CLASS_TYPE_P (ctx) && !uses_template_parms (ctx)) |
209 | perform_or_defer_access_check (TYPE_BINFO (ctx), decl, decl, |
210 | tf_warning_or_error); |
211 | |
212 | maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1); |
213 | |
214 | if (!list) |
215 | DECL_FRIENDLIST (typedecl) |
216 | = tree_cons (DECL_NAME (decl), build_tree_list (NULL_TREE, decl), |
217 | DECL_FRIENDLIST (typedecl)); |
218 | if (!uses_template_parms (type)) |
219 | DECL_BEFRIENDING_CLASSES (decl) |
220 | = tree_cons (NULL_TREE, type, |
221 | DECL_BEFRIENDING_CLASSES (decl)); |
222 | } |
223 | |
224 | /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already |
225 | been defined, we make all of its member functions friends of |
226 | TYPE. If not, we make it a pending friend, which can later be added |
227 | when its definition is seen. If a type is defined, then its TYPE_DECL's |
228 | DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend |
229 | classes that are not defined. If a type has not yet been defined, |
230 | then the DECL_WAITING_FRIENDS contains a list of types |
231 | waiting to make it their friend. Note that these two can both |
232 | be in use at the same time! |
233 | |
234 | If COMPLAIN is true, warning about duplicate friend is issued. |
235 | We want to have this diagnostics during parsing but not |
236 | when a template is being instantiated. */ |
237 | |
238 | void |
239 | make_friend_class (tree type, tree friend_type, bool complain) |
240 | { |
241 | tree classes; |
242 | |
243 | /* CLASS_TEMPLATE_DEPTH counts the number of template headers for |
244 | the enclosing class. FRIEND_DEPTH counts the number of template |
245 | headers used for this friend declaration. TEMPLATE_MEMBER_P, |
246 | defined inside the `if' block for TYPENAME_TYPE case, is true if |
247 | a template header in FRIEND_DEPTH is intended for DECLARATOR. |
248 | For example, the code |
249 | |
250 | template <class T> struct A { |
251 | template <class U> struct B { |
252 | template <class V> template <class W> |
253 | friend class C<V>::D; |
254 | }; |
255 | }; |
256 | |
257 | will eventually give the following results |
258 | |
259 | 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U'). |
260 | 2. FRIEND_DEPTH equals 2 (for `V' and `W'). |
261 | 3. TEMPLATE_MEMBER_P is true (for `W'). |
262 | |
263 | The friend is a template friend iff FRIEND_DEPTH is nonzero. */ |
264 | |
265 | int class_template_depth = template_class_depth (type); |
266 | int friend_depth = 0; |
267 | if (current_template_depth) |
268 | /* When processing a friend declaration at parse time, just compare the |
269 | current depth to that of the class template. */ |
270 | friend_depth = current_template_depth - class_template_depth; |
271 | else |
272 | { |
273 | /* Otherwise, we got here from instantiate_class_template. Determine |
274 | the friend depth by looking at the template parameters used within |
275 | FRIEND_TYPE. */ |
276 | gcc_checking_assert (class_template_depth == 0); |
277 | while (uses_template_parms_level (friend_type, friend_depth + 1)) |
278 | ++friend_depth; |
279 | } |
280 | |
281 | if (! MAYBE_CLASS_TYPE_P (friend_type) |
282 | && TREE_CODE (friend_type) != TEMPLATE_TEMPLATE_PARM) |
283 | { |
284 | /* N1791: If the type specifier in a friend declaration designates a |
285 | (possibly cv-qualified) class type, that class is declared as a |
286 | friend; otherwise, the friend declaration is ignored. |
287 | |
288 | So don't complain in C++11 mode. */ |
289 | if (cxx_dialect < cxx11) |
290 | pedwarn (input_location, complain ? 0 : OPT_Wpedantic, |
291 | "invalid type %qT declared %<friend%>" , friend_type); |
292 | return; |
293 | } |
294 | |
295 | friend_type = cv_unqualified (friend_type); |
296 | |
297 | if (check_for_bare_parameter_packs (friend_type)) |
298 | return; |
299 | |
300 | if (friend_depth) |
301 | { |
302 | /* [temp.friend] Friend declarations shall not declare partial |
303 | specializations. */ |
304 | if (CLASS_TYPE_P (friend_type) |
305 | && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type) |
306 | && uses_template_parms (friend_type)) |
307 | { |
308 | error ("partial specialization %qT declared %<friend%>" , |
309 | friend_type); |
310 | return; |
311 | } |
312 | |
313 | if (TYPE_TEMPLATE_INFO (friend_type) |
314 | && !PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (friend_type))) |
315 | { |
316 | auto_diagnostic_group d; |
317 | error ("%qT is not a template" , friend_type); |
318 | inform (location_of (friend_type), "previous declaration here" ); |
319 | if (TYPE_CLASS_SCOPE_P (friend_type) |
320 | && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (friend_type)) |
321 | && currently_open_class (TYPE_CONTEXT (friend_type))) |
322 | inform (input_location, "perhaps you need explicit template " |
323 | "arguments in your nested-name-specifier" ); |
324 | return; |
325 | } |
326 | } |
327 | |
328 | /* It makes sense for a template class to be friends with itself, |
329 | that means the instantiations can be friendly. Other cases are |
330 | not so meaningful. */ |
331 | if (!friend_depth && same_type_p (type, friend_type)) |
332 | { |
333 | if (complain) |
334 | warning (0, "class %qT is implicitly friends with itself" , |
335 | type); |
336 | return; |
337 | } |
338 | |
339 | /* [temp.friend] |
340 | |
341 | A friend of a class or class template can be a function or |
342 | class template, a specialization of a function template or |
343 | class template, or an ordinary (nontemplate) function or |
344 | class. */ |
345 | if (!friend_depth) |
346 | ;/* ok */ |
347 | else if (TREE_CODE (friend_type) == TYPENAME_TYPE) |
348 | { |
349 | if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type)) |
350 | == TEMPLATE_ID_EXPR) |
351 | { |
352 | /* template <class U> friend class T::X<U>; */ |
353 | /* [temp.friend] |
354 | Friend declarations shall not declare partial |
355 | specializations. */ |
356 | error ("partial specialization %qT declared %<friend%>" , |
357 | friend_type); |
358 | return; |
359 | } |
360 | else |
361 | { |
362 | /* We will figure this out later. */ |
363 | bool template_member_p = false; |
364 | |
365 | tree ctype = TYPE_CONTEXT (friend_type); |
366 | tree name = TYPE_IDENTIFIER (friend_type); |
367 | tree decl; |
368 | |
369 | /* We need to distinguish a TYPENAME_TYPE for the non-template |
370 | class B in |
371 | template<class T> friend class A<T>::B; |
372 | vs for the class template B in |
373 | template<class T> template<class U> friend class A<T>::B; */ |
374 | if (current_template_depth |
375 | && !uses_template_parms_level (ctype, current_template_depth)) |
376 | template_member_p = true; |
377 | |
378 | if (class_template_depth) |
379 | { |
380 | /* We rely on tsubst_friend_class to check the |
381 | validity of the declaration later. */ |
382 | if (template_member_p) |
383 | friend_type |
384 | = make_unbound_class_template (ctype, |
385 | name, |
386 | current_template_parms, |
387 | tf_error); |
388 | else |
389 | friend_type |
390 | = make_typename_type (ctype, name, class_type, tf_error); |
391 | } |
392 | else |
393 | { |
394 | decl = lookup_member (ctype, name, 0, true, tf_warning_or_error); |
395 | if (!decl) |
396 | { |
397 | error ("%qT is not a member of %qT" , name, ctype); |
398 | return; |
399 | } |
400 | if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl)) |
401 | { |
402 | auto_diagnostic_group d; |
403 | error ("%qT is not a member class template of %qT" , |
404 | name, ctype); |
405 | inform (DECL_SOURCE_LOCATION (decl), |
406 | "%qD declared here" , decl); |
407 | return; |
408 | } |
409 | if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL |
410 | || !CLASS_TYPE_P (TREE_TYPE (decl)))) |
411 | { |
412 | auto_diagnostic_group d; |
413 | error ("%qT is not a nested class of %qT" , |
414 | name, ctype); |
415 | inform (DECL_SOURCE_LOCATION (decl), |
416 | "%qD declared here" , decl); |
417 | return; |
418 | } |
419 | |
420 | friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)); |
421 | } |
422 | } |
423 | } |
424 | else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM) |
425 | { |
426 | /* template <class T> friend class T; */ |
427 | error ("template parameter type %qT declared %<friend%>" , friend_type); |
428 | return; |
429 | } |
430 | else if (TREE_CODE (friend_type) == TEMPLATE_TEMPLATE_PARM) |
431 | friend_type = TYPE_NAME (friend_type); |
432 | else if (!CLASSTYPE_TEMPLATE_INFO (friend_type)) |
433 | { |
434 | /* template <class T> friend class A; where A is not a template */ |
435 | error ("%q#T is not a template" , friend_type); |
436 | return; |
437 | } |
438 | else |
439 | /* template <class T> friend class A; where A is a template */ |
440 | friend_type = CLASSTYPE_TI_TEMPLATE (friend_type); |
441 | |
442 | if (friend_type == error_mark_node) |
443 | return; |
444 | |
445 | /* See if it is already a friend. */ |
446 | for (classes = CLASSTYPE_FRIEND_CLASSES (type); |
447 | classes; |
448 | classes = TREE_CHAIN (classes)) |
449 | { |
450 | tree probe = TREE_VALUE (classes); |
451 | |
452 | if (TREE_CODE (friend_type) == TEMPLATE_DECL) |
453 | { |
454 | if (friend_type == probe) |
455 | { |
456 | if (complain) |
457 | warning (OPT_Wredundant_decls, |
458 | "%qD is already a friend of %qT" , probe, type); |
459 | break; |
460 | } |
461 | } |
462 | else if (TREE_CODE (probe) != TEMPLATE_DECL) |
463 | { |
464 | if (same_type_p (probe, friend_type)) |
465 | { |
466 | if (complain) |
467 | warning (OPT_Wredundant_decls, |
468 | "%qT is already a friend of %qT" , probe, type); |
469 | break; |
470 | } |
471 | } |
472 | } |
473 | |
474 | if (!classes) |
475 | { |
476 | maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1); |
477 | |
478 | CLASSTYPE_FRIEND_CLASSES (type) |
479 | = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type)); |
480 | if (TREE_CODE (friend_type) == TEMPLATE_DECL) |
481 | friend_type = TREE_TYPE (friend_type); |
482 | if (!uses_template_parms (type)) |
483 | CLASSTYPE_BEFRIENDING_CLASSES (friend_type) |
484 | = tree_cons (NULL_TREE, type, |
485 | CLASSTYPE_BEFRIENDING_CLASSES (friend_type)); |
486 | } |
487 | } |
488 | |
489 | /* Record DECL (a FUNCTION_DECL) as a friend of the |
490 | CURRENT_CLASS_TYPE. If DECL is a member function, SCOPE is the |
491 | class of which it is a member, as named in the friend declaration. |
492 | If the friend declaration was explicitly namespace-qualified, SCOPE |
493 | is that namespace. |
494 | DECLARATOR is the name of the friend. FUNCDEF_FLAG is true if the |
495 | friend declaration is a definition of the function. FLAGS is as |
496 | for grokclass fn. */ |
497 | |
498 | tree |
499 | do_friend (tree scope, tree declarator, tree decl, |
500 | enum overload_flags flags, |
501 | bool funcdef_flag) |
502 | { |
503 | gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); |
504 | |
505 | tree ctype = NULL_TREE; |
506 | tree in_namespace = NULL_TREE; |
507 | if (!scope) |
508 | ; |
509 | else if (MAYBE_CLASS_TYPE_P (scope)) |
510 | ctype = scope; |
511 | else |
512 | { |
513 | gcc_checking_assert (TREE_CODE (scope) == NAMESPACE_DECL); |
514 | in_namespace = scope; |
515 | } |
516 | |
517 | /* Friend functions are unique, until proved otherwise. */ |
518 | DECL_UNIQUE_FRIEND_P (decl) = 1; |
519 | |
520 | if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl)) |
521 | error ("friend declaration %qD may not have virt-specifiers" , |
522 | decl); |
523 | |
524 | tree orig_declarator = declarator; |
525 | if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) |
526 | { |
527 | declarator = TREE_OPERAND (declarator, 0); |
528 | if (!identifier_p (t: declarator)) |
529 | declarator = OVL_NAME (declarator); |
530 | } |
531 | |
532 | /* CLASS_TEMPLATE_DEPTH counts the number of template headers for |
533 | the enclosing class. FRIEND_DEPTH counts the number of template |
534 | headers used for this friend declaration. TEMPLATE_MEMBER_P is |
535 | true if a template header in FRIEND_DEPTH is intended for |
536 | DECLARATOR. For example, the code |
537 | |
538 | template <class T> struct A { |
539 | template <class U> struct B { |
540 | template <class V> template <class W> |
541 | friend void C<V>::f(W); |
542 | }; |
543 | }; |
544 | |
545 | will eventually give the following results |
546 | |
547 | 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U'). |
548 | 2. FRIEND_DEPTH equals 2 (for `V' and `W'). |
549 | 3. CTYPE_DEPTH equals 1 (for `V'). |
550 | 4. TEMPLATE_MEMBER_P is true (for `W'). */ |
551 | |
552 | int class_template_depth = template_class_depth (current_class_type); |
553 | int friend_depth = current_template_depth - class_template_depth; |
554 | int ctype_depth = num_template_headers_for_class (ctype); |
555 | bool template_member_p = friend_depth > ctype_depth; |
556 | |
557 | if (ctype) |
558 | { |
559 | tree cname = TYPE_NAME (ctype); |
560 | if (TREE_CODE (cname) == TYPE_DECL) |
561 | cname = DECL_NAME (cname); |
562 | |
563 | /* A method friend. */ |
564 | if (flags == NO_SPECIAL && declarator == cname) |
565 | DECL_CXX_CONSTRUCTOR_P (decl) = 1; |
566 | |
567 | grokclassfn (ctype, decl, flags); |
568 | |
569 | /* A nested class may declare a member of an enclosing class |
570 | to be a friend, so we do lookup here even if CTYPE is in |
571 | the process of being defined. */ |
572 | if (class_template_depth |
573 | || COMPLETE_OR_OPEN_TYPE_P (ctype)) |
574 | { |
575 | if (DECL_TEMPLATE_INFO (decl)) |
576 | /* DECL is a template specialization. No need to |
577 | build a new TEMPLATE_DECL. */ |
578 | ; |
579 | else if (class_template_depth) |
580 | /* We rely on tsubst_friend_function to check the |
581 | validity of the declaration later. */ |
582 | decl = push_template_decl (decl, /*is_friend=*/true); |
583 | else |
584 | decl = check_classfn (ctype, decl, |
585 | template_member_p |
586 | ? current_template_parms |
587 | : NULL_TREE); |
588 | |
589 | if ((template_member_p |
590 | /* Always pull out the TEMPLATE_DECL if we have a friend |
591 | template in a class template so that it gets tsubsted |
592 | properly later on (59956). tsubst_friend_function knows |
593 | how to tell this apart from a member template. */ |
594 | || (class_template_depth && friend_depth)) |
595 | && decl && TREE_CODE (decl) == FUNCTION_DECL) |
596 | decl = DECL_TI_TEMPLATE (decl); |
597 | } |
598 | else |
599 | error ("member %qD declared as friend before type %qT defined" , |
600 | decl, ctype); |
601 | } |
602 | else |
603 | { |
604 | /* Namespace-scope friend function. */ |
605 | |
606 | if (funcdef_flag) |
607 | SET_DECL_FRIEND_CONTEXT (decl, current_class_type); |
608 | |
609 | if (! DECL_USE_TEMPLATE (decl)) |
610 | { |
611 | /* We must check whether the decl refers to template |
612 | arguments before push_template_decl adds a reference to |
613 | the containing template class. */ |
614 | int warn = (warn_nontemplate_friend |
615 | && ! funcdef_flag && ! friend_depth |
616 | && current_template_parms |
617 | && uses_template_parms (decl)); |
618 | |
619 | if (friend_depth || class_template_depth) |
620 | /* We can't call pushdecl for a template class, since in |
621 | general, such a declaration depends on template |
622 | parameters. Instead, we call pushdecl when the class |
623 | is instantiated. */ |
624 | decl = push_template_decl (decl, /*is_friend=*/true); |
625 | else if (current_function_decl && !in_namespace) |
626 | /* pushdecl will check there's a local decl already. */ |
627 | decl = pushdecl (decl, /*hiding=*/true); |
628 | else |
629 | { |
630 | /* We can't use pushdecl, as we might be in a template |
631 | class specialization, and pushdecl will insert an |
632 | unqualified friend decl into the template parameter |
633 | scope, rather than the namespace containing it. */ |
634 | tree ns = decl_namespace_context (decl); |
635 | |
636 | push_nested_namespace (ns); |
637 | decl = pushdecl_namespace_level (decl, /*hiding=*/true); |
638 | pop_nested_namespace (ns); |
639 | } |
640 | |
641 | if (warn) |
642 | { |
643 | static int explained; |
644 | bool warned; |
645 | |
646 | auto_diagnostic_group d; |
647 | warned = warning (OPT_Wnon_template_friend, "friend declaration " |
648 | "%q#D declares a non-template function" , decl); |
649 | if (! explained && warned) |
650 | { |
651 | inform (input_location, "(if this is not what you intended, " |
652 | "make sure the function template has already been " |
653 | "declared and add %<<>%> after the function name " |
654 | "here)" ); |
655 | explained = 1; |
656 | } |
657 | } |
658 | } |
659 | } |
660 | |
661 | if (decl == error_mark_node) |
662 | return error_mark_node; |
663 | |
664 | if (!class_template_depth && DECL_IMPLICIT_INSTANTIATION (decl) |
665 | && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL) |
666 | /* "[if no non-template match is found,] each remaining function template |
667 | is replaced with the specialization chosen by deduction from the |
668 | friend declaration or discarded if deduction fails." |
669 | |
670 | set_decl_namespace or check_classfn set DECL_IMPLICIT_INSTANTIATION to |
671 | indicate that we need a template match, so ask |
672 | check_explicit_specialization to find one. */ |
673 | decl = (check_explicit_specialization |
674 | (orig_declarator, decl, ctype_depth, |
675 | 2 * funcdef_flag + 4)); |
676 | |
677 | add_friend (current_class_type, |
678 | decl: (!ctype && friend_depth) ? DECL_TI_TEMPLATE (decl) : decl, |
679 | /*complain=*/true); |
680 | |
681 | return decl; |
682 | } |
683 | |
684 | #include "gt-cp-friend.h" |
685 | |