1 /* Help friends in C++.
2 Copyright (C) 1997-2020 Free Software Foundation, Inc.
4 This file is part of GCC.
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)
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.
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/>. */
22 #include "coretypes.h"
25 /* Friend data structures are described in cp-tree.h. */
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). */
35 static GTY(()) tree global_friend
;
37 /* Set the GLOBAL_FRIEND for this compilation session. It might be
38 set multiple times, but always to the same scope. */
41 set_global_friend (tree scope
)
43 gcc_checking_assert (scope
!= NULL_TREE
);
44 gcc_assert (!global_friend
|| global_friend
== scope
);
45 global_friend
= scope
;
48 /* Return TRUE if SCOPE is the global friend. */
51 is_global_friend (tree scope
)
53 gcc_checking_assert (scope
!= NULL_TREE
);
55 if (global_friend
== scope
)
61 if (is_specialization_of_friend (global_friend
, scope
))
67 /* Returns nonzero if SUPPLICANT is a friend of TYPE. */
70 is_friend (tree type
, tree supplicant
)
76 if (supplicant
== NULL_TREE
|| type
== NULL_TREE
)
79 if (is_global_friend (supplicant
))
82 declp
= DECL_P (supplicant
);
85 /* It's a function decl. */
87 tree list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
));
88 tree name
= DECL_NAME (supplicant
);
90 for (; list
; list
= TREE_CHAIN (list
))
92 if (name
== FRIEND_NAME (list
))
94 tree friends
= FRIEND_DECLS (list
);
95 for (; friends
; friends
= TREE_CHAIN (friends
))
97 tree this_friend
= TREE_VALUE (friends
);
99 if (this_friend
== NULL_TREE
)
102 if (supplicant
== this_friend
)
105 if (is_specialization_of_friend (supplicant
, this_friend
))
115 if (same_type_p (supplicant
, type
))
118 list
= CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type
)));
119 for (; list
; list
= TREE_CHAIN (list
))
121 tree t
= TREE_VALUE (list
);
123 if (TREE_CODE (t
) == TEMPLATE_DECL
?
124 is_specialization_of_friend (TYPE_MAIN_DECL (supplicant
), t
) :
125 same_type_p (supplicant
, t
))
132 if (DECL_FUNCTION_MEMBER_P (supplicant
))
133 context
= DECL_CONTEXT (supplicant
);
139 if (TYPE_CLASS_SCOPE_P (supplicant
))
140 /* Nested classes get the same access as their enclosing types, as
141 per DR 45 (this is a change from the standard). */
142 context
= TYPE_CONTEXT (supplicant
);
144 /* Local classes have the same access as the enclosing function. */
145 context
= decl_function_context (TYPE_MAIN_DECL (supplicant
));
148 /* A namespace is not friend to anybody. */
149 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
153 return is_friend (type
, context
);
158 /* Add a new friend to the friends of the aggregate type TYPE.
159 DECL is the FUNCTION_DECL of the friend being added.
161 If COMPLAIN is true, warning about duplicate friend is issued.
162 We want to have this diagnostics during parsing but not
163 when a template is being instantiated. */
166 add_friend (tree type
, tree decl
, bool complain
)
173 if (decl
== error_mark_node
)
176 typedecl
= TYPE_MAIN_DECL (type
);
177 list
= DECL_FRIENDLIST (typedecl
);
178 name
= DECL_NAME (decl
);
179 type
= TREE_TYPE (typedecl
);
183 if (name
== FRIEND_NAME (list
))
185 tree friends
= FRIEND_DECLS (list
);
186 for (; friends
; friends
= TREE_CHAIN (friends
))
188 if (decl
== TREE_VALUE (friends
))
191 warning (OPT_Wredundant_decls
,
192 "%qD is already a friend of class %qT",
198 TREE_VALUE (list
) = tree_cons (NULL_TREE
, decl
,
202 list
= TREE_CHAIN (list
);
205 ctx
= DECL_CONTEXT (decl
);
206 if (ctx
&& CLASS_TYPE_P (ctx
) && !uses_template_parms (ctx
))
207 perform_or_defer_access_check (TYPE_BINFO (ctx
), decl
, decl
,
208 tf_warning_or_error
);
210 maybe_add_class_template_decl_list (type
, decl
, /*friend_p=*/1);
213 DECL_FRIENDLIST (typedecl
)
214 = tree_cons (DECL_NAME (decl
), build_tree_list (NULL_TREE
, decl
),
215 DECL_FRIENDLIST (typedecl
));
216 if (!uses_template_parms (type
))
217 DECL_BEFRIENDING_CLASSES (decl
)
218 = tree_cons (NULL_TREE
, type
,
219 DECL_BEFRIENDING_CLASSES (decl
));
222 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already
223 been defined, we make all of its member functions friends of
224 TYPE. If not, we make it a pending friend, which can later be added
225 when its definition is seen. If a type is defined, then its TYPE_DECL's
226 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
227 classes that are not defined. If a type has not yet been defined,
228 then the DECL_WAITING_FRIENDS contains a list of types
229 waiting to make it their friend. Note that these two can both
230 be in use at the same time!
232 If COMPLAIN is true, warning about duplicate friend is issued.
233 We want to have this diagnostics during parsing but not
234 when a template is being instantiated. */
237 make_friend_class (tree type
, tree friend_type
, bool complain
)
241 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
242 the enclosing class. FRIEND_DEPTH counts the number of template
243 headers used for this friend declaration. TEMPLATE_MEMBER_P,
244 defined inside the `if' block for TYPENAME_TYPE case, is true if
245 a template header in FRIEND_DEPTH is intended for DECLARATOR.
246 For example, the code
248 template <class T> struct A {
249 template <class U> struct B {
250 template <class V> template <class W>
251 friend class C<V>::D;
255 will eventually give the following results
257 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
258 2. FRIEND_DEPTH equals 2 (for `V' and `W').
259 3. TEMPLATE_MEMBER_P is true (for `W').
261 The friend is a template friend iff FRIEND_DEPTH is nonzero. */
263 int class_template_depth
= template_class_depth (type
);
264 int friend_depth
= processing_template_decl
- class_template_depth
;
266 if (! MAYBE_CLASS_TYPE_P (friend_type
)
267 && TREE_CODE (friend_type
) != TEMPLATE_TEMPLATE_PARM
)
269 /* N1791: If the type specifier in a friend declaration designates a
270 (possibly cv-qualified) class type, that class is declared as a
271 friend; otherwise, the friend declaration is ignored.
273 So don't complain in C++11 mode. */
274 if (cxx_dialect
< cxx11
)
275 pedwarn (input_location
, complain
? 0 : OPT_Wpedantic
,
276 "invalid type %qT declared %<friend%>", friend_type
);
280 friend_type
= cv_unqualified (friend_type
);
282 if (check_for_bare_parameter_packs (friend_type
))
287 /* [temp.friend] Friend declarations shall not declare partial
289 if (CLASS_TYPE_P (friend_type
)
290 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type
)
291 && uses_template_parms (friend_type
))
293 error ("partial specialization %qT declared %<friend%>",
298 if (TYPE_TEMPLATE_INFO (friend_type
)
299 && !PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (friend_type
)))
301 auto_diagnostic_group d
;
302 error ("%qT is not a template", friend_type
);
303 inform (location_of (friend_type
), "previous declaration here");
304 if (TYPE_CLASS_SCOPE_P (friend_type
)
305 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (friend_type
))
306 && currently_open_class (TYPE_CONTEXT (friend_type
)))
307 inform (input_location
, "perhaps you need explicit template "
308 "arguments in your nested-name-specifier");
313 /* It makes sense for a template class to be friends with itself,
314 that means the instantiations can be friendly. Other cases are
315 not so meaningful. */
316 if (!friend_depth
&& same_type_p (type
, friend_type
))
319 warning (0, "class %qT is implicitly friends with itself",
326 A friend of a class or class template can be a function or
327 class template, a specialization of a function template or
328 class template, or an ordinary (nontemplate) function or
332 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
)
334 if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type
))
337 /* template <class U> friend class T::X<U>; */
339 Friend declarations shall not declare partial
341 error ("partial specialization %qT declared %<friend%>",
347 /* We will figure this out later. */
348 bool template_member_p
= false;
350 tree ctype
= TYPE_CONTEXT (friend_type
);
351 tree name
= TYPE_IDENTIFIER (friend_type
);
354 if (!uses_template_parms_level (ctype
, class_template_depth
356 template_member_p
= true;
358 if (class_template_depth
)
360 /* We rely on tsubst_friend_class to check the
361 validity of the declaration later. */
362 if (template_member_p
)
364 = make_unbound_class_template (ctype
,
366 current_template_parms
,
370 = make_typename_type (ctype
, name
, class_type
, tf_error
);
374 decl
= lookup_member (ctype
, name
, 0, true, tf_warning_or_error
);
377 error ("%qT is not a member of %qT", name
, ctype
);
380 if (template_member_p
&& !DECL_CLASS_TEMPLATE_P (decl
))
382 auto_diagnostic_group d
;
383 error ("%qT is not a member class template of %qT",
385 inform (DECL_SOURCE_LOCATION (decl
),
386 "%qD declared here", decl
);
389 if (!template_member_p
&& (TREE_CODE (decl
) != TYPE_DECL
390 || !CLASS_TYPE_P (TREE_TYPE (decl
))))
392 auto_diagnostic_group d
;
393 error ("%qT is not a nested class of %qT",
395 inform (DECL_SOURCE_LOCATION (decl
),
396 "%qD declared here", decl
);
400 friend_type
= CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
));
404 else if (TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
406 /* template <class T> friend class T; */
407 error ("template parameter type %qT declared %<friend%>", friend_type
);
410 else if (TREE_CODE (friend_type
) == TEMPLATE_TEMPLATE_PARM
)
411 friend_type
= TYPE_NAME (friend_type
);
412 else if (!CLASSTYPE_TEMPLATE_INFO (friend_type
))
414 /* template <class T> friend class A; where A is not a template */
415 error ("%q#T is not a template", friend_type
);
419 /* template <class T> friend class A; where A is a template */
420 friend_type
= CLASSTYPE_TI_TEMPLATE (friend_type
);
422 if (friend_type
== error_mark_node
)
425 /* See if it is already a friend. */
426 for (classes
= CLASSTYPE_FRIEND_CLASSES (type
);
428 classes
= TREE_CHAIN (classes
))
430 tree probe
= TREE_VALUE (classes
);
432 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
434 if (friend_type
== probe
)
437 warning (OPT_Wredundant_decls
,
438 "%qD is already a friend of %qT", probe
, type
);
442 else if (TREE_CODE (probe
) != TEMPLATE_DECL
)
444 if (same_type_p (probe
, friend_type
))
447 warning (OPT_Wredundant_decls
,
448 "%qT is already a friend of %qT", probe
, type
);
456 maybe_add_class_template_decl_list (type
, friend_type
, /*friend_p=*/1);
458 CLASSTYPE_FRIEND_CLASSES (type
)
459 = tree_cons (NULL_TREE
, friend_type
, CLASSTYPE_FRIEND_CLASSES (type
));
460 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
461 friend_type
= TREE_TYPE (friend_type
);
462 if (!uses_template_parms (type
))
463 CLASSTYPE_BEFRIENDING_CLASSES (friend_type
)
464 = tree_cons (NULL_TREE
, type
,
465 CLASSTYPE_BEFRIENDING_CLASSES (friend_type
));
469 /* Record DECL (a FUNCTION_DECL) as a friend of the
470 CURRENT_CLASS_TYPE. If DECL is a member function, CTYPE is the
471 class of which it is a member, as named in the friend declaration.
472 DECLARATOR is the name of the friend. FUNCDEF_FLAG is true if the
473 friend declaration is a definition of the function. FLAGS is as
477 do_friend (tree ctype
, tree declarator
, tree decl
,
478 tree attrlist
, enum overload_flags flags
,
481 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
482 gcc_assert (!ctype
|| MAYBE_CLASS_TYPE_P (ctype
));
484 /* Every decl that gets here is a friend of something. */
485 DECL_FRIEND_P (decl
) = 1;
487 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
488 error ("friend declaration %qD may not have virt-specifiers",
491 /* Unfortunately, we have to handle attributes here. Normally we would
492 handle them in start_decl_1, but since this is a friend decl start_decl_1
493 never gets to see it. */
495 /* Set attributes here so if duplicate decl, will have proper attributes. */
496 cplus_decl_attributes (&decl
, attrlist
, 0);
498 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
500 declarator
= TREE_OPERAND (declarator
, 0);
501 if (!identifier_p (declarator
))
502 declarator
= OVL_NAME (declarator
);
507 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
508 the enclosing class. FRIEND_DEPTH counts the number of template
509 headers used for this friend declaration. TEMPLATE_MEMBER_P is
510 true if a template header in FRIEND_DEPTH is intended for
511 DECLARATOR. For example, the code
513 template <class T> struct A {
514 template <class U> struct B {
515 template <class V> template <class W>
516 friend void C<V>::f(W);
520 will eventually give the following results
522 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
523 2. FRIEND_DEPTH equals 2 (for `V' and `W').
524 3. TEMPLATE_MEMBER_P is true (for `W'). */
526 int class_template_depth
= template_class_depth (current_class_type
);
527 int friend_depth
= processing_template_decl
- class_template_depth
;
528 /* We will figure this out later. */
529 bool template_member_p
= false;
531 tree cname
= TYPE_NAME (ctype
);
532 if (TREE_CODE (cname
) == TYPE_DECL
)
533 cname
= DECL_NAME (cname
);
535 /* A method friend. */
536 if (flags
== NO_SPECIAL
&& declarator
== cname
)
537 DECL_CXX_CONSTRUCTOR_P (decl
) = 1;
539 grokclassfn (ctype
, decl
, flags
);
543 if (!uses_template_parms_level (ctype
, class_template_depth
545 template_member_p
= true;
548 /* A nested class may declare a member of an enclosing class
549 to be a friend, so we do lookup here even if CTYPE is in
550 the process of being defined. */
551 if (class_template_depth
552 || COMPLETE_OR_OPEN_TYPE_P (ctype
))
554 if (DECL_TEMPLATE_INFO (decl
))
555 /* DECL is a template specialization. No need to
556 build a new TEMPLATE_DECL. */
558 else if (class_template_depth
)
559 /* We rely on tsubst_friend_function to check the
560 validity of the declaration later. */
561 decl
= push_template_decl_real (decl
, /*is_friend=*/true);
563 decl
= check_classfn (ctype
, decl
,
565 ? current_template_parms
568 if ((template_member_p
569 /* Always pull out the TEMPLATE_DECL if we have a friend
570 template in a class template so that it gets tsubsted
571 properly later on (59956). tsubst_friend_function knows
572 how to tell this apart from a member template. */
573 || (class_template_depth
&& friend_depth
))
574 && decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
575 decl
= DECL_TI_TEMPLATE (decl
);
578 add_friend (current_class_type
, decl
, /*complain=*/true);
581 error ("member %qD declared as friend before type %qT defined",
585 @@ or possibly a friend from a base class ?!? */
586 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
588 int is_friend_template
= PROCESSING_REAL_TEMPLATE_DECL_P ();
590 /* Friends must all go through the overload machinery,
591 even though they may not technically be overloaded.
593 Note that because classes all wind up being top-level
594 in their scope, their friend wind up in top-level scope as well. */
596 SET_DECL_FRIEND_CONTEXT (decl
, current_class_type
);
598 if (! DECL_USE_TEMPLATE (decl
))
600 /* We must check whether the decl refers to template
601 arguments before push_template_decl_real adds a
602 reference to the containing template class. */
603 int warn
= (warn_nontemplate_friend
604 && ! funcdef_flag
&& ! is_friend_template
605 && current_template_parms
606 && uses_template_parms (decl
));
608 if (is_friend_template
609 || template_class_depth (current_class_type
) != 0)
610 /* We can't call pushdecl for a template class, since in
611 general, such a declaration depends on template
612 parameters. Instead, we call pushdecl when the class
614 decl
= push_template_decl_real (decl
, /*is_friend=*/true);
615 else if (current_function_decl
)
616 /* pushdecl will check there's a local decl already. */
617 decl
= pushdecl (decl
, /*is_friend=*/true);
620 /* We can't use pushdecl, as we might be in a template
621 class specialization, and pushdecl will insert an
622 unqualified friend decl into the template parameter
623 scope, rather than the namespace containing it. */
624 tree ns
= decl_namespace_context (decl
);
626 push_nested_namespace (ns
);
627 decl
= pushdecl_namespace_level (decl
, /*is_friend=*/true);
628 pop_nested_namespace (ns
);
633 static int explained
;
636 auto_diagnostic_group d
;
637 warned
= warning (OPT_Wnon_template_friend
, "friend declaration "
638 "%q#D declares a non-template function", decl
);
639 if (! explained
&& warned
)
641 inform (input_location
, "(if this is not what you intended, "
642 "make sure the function template has already been "
643 "declared and add %<<>%> after the function name "
650 if (decl
== error_mark_node
)
651 return error_mark_node
;
653 add_friend (current_class_type
,
654 is_friend_template
? DECL_TI_TEMPLATE (decl
) : decl
,
656 DECL_FRIEND_P (decl
) = 1;
662 #include "gt-cp-friend.h"