1/* Help friends in C++.
2 Copyright (C) 1997-2024 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 3, or (at your option)
9any later version.
10
11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along 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
35static 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
40void
41set_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
50bool
51is_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
69int
70is_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
167void
168add_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
238void
239make_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
498tree
499do_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

source code of gcc/cp/friend.cc