1/* Help friends in C++.
2 Copyright (C) 1997-2017 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 (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
135 context = NULL_TREE;
136 }
137 else
138 {
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);
143 else
144 /* Local classes have the same access as the enclosing function. */
145 context = decl_function_context (TYPE_MAIN_DECL (supplicant));
146 }
147
148 /* A namespace is not friend to anybody. */
149 if (context && TREE_CODE (context) == NAMESPACE_DECL)
150 context = NULL_TREE;
151
152 if (context)
153 return is_friend (type, context);
154
155 return 0;
156}
157
158/* Add a new friend to the friends of the aggregate type TYPE.
159 DECL is the FUNCTION_DECL of the friend being added.
160
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. */
164
165void
166add_friend (tree type, tree decl, bool complain)
167{
168 tree typedecl;
169 tree list;
170 tree name;
171 tree ctx;
172
173 if (decl == error_mark_node)
174 return;
175
176 typedecl = TYPE_MAIN_DECL (type);
177 list = DECL_FRIENDLIST (typedecl);
178 name = DECL_NAME (decl);
179 type = TREE_TYPE (typedecl);
180
181 while (list)
182 {
183 if (name == FRIEND_NAME (list))
184 {
185 tree friends = FRIEND_DECLS (list);
186 for (; friends ; friends = TREE_CHAIN (friends))
187 {
188 if (decl == TREE_VALUE (friends))
189 {
190 if (complain)
191 warning (OPT_Wredundant_decls,
192 "%qD is already a friend of class %qT",
193 decl, type);
194 return;
195 }
196 }
197
198 TREE_VALUE (list) = tree_cons (NULL_TREE, decl,
199 TREE_VALUE (list));
200 break;
201 }
202 list = TREE_CHAIN (list);
203 }
204
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);
209
210 maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
211
212 if (!list)
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));
220}
221
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!
231
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. */
235
236void
237make_friend_class (tree type, tree friend_type, bool complain)
238{
239 tree classes;
240
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
247
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;
252 };
253 };
254
255 will eventually give the following results
256
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').
260
261 The friend is a template friend iff FRIEND_DEPTH is nonzero. */
262
263 int class_template_depth = template_class_depth (type);
264 int friend_depth = processing_template_decl - class_template_depth;
265
266 if (! MAYBE_CLASS_TYPE_P (friend_type)
267 && TREE_CODE (friend_type) != TEMPLATE_TEMPLATE_PARM)
268 {
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.
272
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);
277 return;
278 }
279
280 friend_type = cv_unqualified (friend_type);
281
282 if (check_for_bare_parameter_packs (friend_type))
283 return;
284
285 if (friend_depth)
286 /* If the TYPE is a template then it makes sense for it to be
287 friends with itself; this means that each instantiation is
288 friends with all other instantiations. */
289 {
290 if (CLASS_TYPE_P (friend_type)
291 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type)
292 && uses_template_parms (friend_type))
293 {
294 /* [temp.friend]
295 Friend declarations shall not declare partial
296 specializations. */
297 error ("partial specialization %qT declared %<friend%>",
298 friend_type);
299 return;
300 }
301 if (TYPE_TEMPLATE_INFO (friend_type)
302 && !PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (friend_type)))
303 {
304 error ("%qT is not a template", friend_type);
305 inform (location_of (friend_type), "previous declaration here");
306 if (TYPE_CLASS_SCOPE_P (friend_type)
307 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (friend_type))
308 && currently_open_class (TYPE_CONTEXT (friend_type)))
309 inform (input_location, "perhaps you need explicit template "
310 "arguments in your nested-name-specifier");
311 return;
312 }
313 }
314 else if (same_type_p (type, friend_type))
315 {
316 if (complain)
317 warning (0, "class %qT is implicitly friends with itself",
318 type);
319 return;
320 }
321
322 /* [temp.friend]
323
324 A friend of a class or class template can be a function or
325 class template, a specialization of a function template or
326 class template, or an ordinary (nontemplate) function or
327 class. */
328 if (!friend_depth)
329 ;/* ok */
330 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
331 {
332 if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type))
333 == TEMPLATE_ID_EXPR)
334 {
335 /* template <class U> friend class T::X<U>; */
336 /* [temp.friend]
337 Friend declarations shall not declare partial
338 specializations. */
339 error ("partial specialization %qT declared %<friend%>",
340 friend_type);
341 return;
342 }
343 else
344 {
345 /* We will figure this out later. */
346 bool template_member_p = false;
347
348 tree ctype = TYPE_CONTEXT (friend_type);
349 tree name = TYPE_IDENTIFIER (friend_type);
350 tree decl;
351
352 if (!uses_template_parms_level (ctype, class_template_depth
353 + friend_depth))
354 template_member_p = true;
355
356 if (class_template_depth)
357 {
358 /* We rely on tsubst_friend_class to check the
359 validity of the declaration later. */
360 if (template_member_p)
361 friend_type
362 = make_unbound_class_template (ctype,
363 name,
364 current_template_parms,
365 tf_error);
366 else
367 friend_type
368 = make_typename_type (ctype, name, class_type, tf_error);
369 }
370 else
371 {
372 decl = lookup_member (ctype, name, 0, true, tf_warning_or_error);
373 if (!decl)
374 {
375 error ("%qT is not a member of %qT", name, ctype);
376 return;
377 }
378 if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl))
379 {
380 error ("%qT is not a member class template of %qT",
381 name, ctype);
382 inform (DECL_SOURCE_LOCATION (decl),
383 "%qD declared here", decl);
384 return;
385 }
386 if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL
387 || !CLASS_TYPE_P (TREE_TYPE (decl))))
388 {
389 error ("%qT is not a nested class of %qT",
390 name, ctype);
391 inform (DECL_SOURCE_LOCATION (decl),
392 "%qD declared here", decl);
393 return;
394 }
395
396 friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl));
397 }
398 }
399 }
400 else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
401 {
402 /* template <class T> friend class T; */
403 error ("template parameter type %qT declared %<friend%>", friend_type);
404 return;
405 }
406 else if (TREE_CODE (friend_type) == TEMPLATE_TEMPLATE_PARM)
407 friend_type = TYPE_NAME (friend_type);
408 else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
409 {
410 /* template <class T> friend class A; where A is not a template */
411 error ("%q#T is not a template", friend_type);
412 return;
413 }
414 else
415 /* template <class T> friend class A; where A is a template */
416 friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
417
418 if (friend_type == error_mark_node)
419 return;
420
421 /* See if it is already a friend. */
422 for (classes = CLASSTYPE_FRIEND_CLASSES (type);
423 classes;
424 classes = TREE_CHAIN (classes))
425 {
426 tree probe = TREE_VALUE (classes);
427
428 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
429 {
430 if (friend_type == probe)
431 {
432 if (complain)
433 warning (OPT_Wredundant_decls,
434 "%qD is already a friend of %qT", probe, type);
435 break;
436 }
437 }
438 else if (TREE_CODE (probe) != TEMPLATE_DECL)
439 {
440 if (same_type_p (probe, friend_type))
441 {
442 if (complain)
443 warning (OPT_Wredundant_decls,
444 "%qT is already a friend of %qT", probe, type);
445 break;
446 }
447 }
448 }
449
450 if (!classes)
451 {
452 maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1);
453
454 CLASSTYPE_FRIEND_CLASSES (type)
455 = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
456 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
457 friend_type = TREE_TYPE (friend_type);
458 if (!uses_template_parms (type))
459 CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
460 = tree_cons (NULL_TREE, type,
461 CLASSTYPE_BEFRIENDING_CLASSES (friend_type));
462 }
463}
464
465/* Record DECL (a FUNCTION_DECL) as a friend of the
466 CURRENT_CLASS_TYPE. If DECL is a member function, CTYPE is the
467 class of which it is a member, as named in the friend declaration.
468 DECLARATOR is the name of the friend. FUNCDEF_FLAG is true if the
469 friend declaration is a definition of the function. FLAGS is as
470 for grokclass fn. */
471
472tree
473do_friend (tree ctype, tree declarator, tree decl,
474 tree attrlist, enum overload_flags flags,
475 bool funcdef_flag)
476{
477 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
478 gcc_assert (!ctype || MAYBE_CLASS_TYPE_P (ctype));
479
480 /* Every decl that gets here is a friend of something. */
481 DECL_FRIEND_P (decl) = 1;
482
483 if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl))
484 error ("friend declaration %qD may not have virt-specifiers",
485 decl);
486
487 /* Unfortunately, we have to handle attributes here. Normally we would
488 handle them in start_decl_1, but since this is a friend decl start_decl_1
489 never gets to see it. */
490
491 /* Set attributes here so if duplicate decl, will have proper attributes. */
492 cplus_decl_attributes (&decl, attrlist, 0);
493
494 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
495 {
496 declarator = TREE_OPERAND (declarator, 0);
497 declarator = OVL_NAME (declarator);
498 }
499
500 if (ctype)
501 {
502 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
503 the enclosing class. FRIEND_DEPTH counts the number of template
504 headers used for this friend declaration. TEMPLATE_MEMBER_P is
505 true if a template header in FRIEND_DEPTH is intended for
506 DECLARATOR. For example, the code
507
508 template <class T> struct A {
509 template <class U> struct B {
510 template <class V> template <class W>
511 friend void C<V>::f(W);
512 };
513 };
514
515 will eventually give the following results
516
517 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
518 2. FRIEND_DEPTH equals 2 (for `V' and `W').
519 3. TEMPLATE_MEMBER_P is true (for `W'). */
520
521 int class_template_depth = template_class_depth (current_class_type);
522 int friend_depth = processing_template_decl - class_template_depth;
523 /* We will figure this out later. */
524 bool template_member_p = false;
525
526 tree cname = TYPE_NAME (ctype);
527 if (TREE_CODE (cname) == TYPE_DECL)
528 cname = DECL_NAME (cname);
529
530 /* A method friend. */
531 if (flags == NO_SPECIAL && declarator == cname)
532 DECL_CXX_CONSTRUCTOR_P (decl) = 1;
533
534 grokclassfn (ctype, decl, flags);
535
536 if (friend_depth)
537 {
538 if (!uses_template_parms_level (ctype, class_template_depth
539 + friend_depth))
540 template_member_p = true;
541 }
542
543 /* A nested class may declare a member of an enclosing class
544 to be a friend, so we do lookup here even if CTYPE is in
545 the process of being defined. */
546 if (class_template_depth
547 || COMPLETE_OR_OPEN_TYPE_P (ctype))
548 {
549 if (DECL_TEMPLATE_INFO (decl))
550 /* DECL is a template specialization. No need to
551 build a new TEMPLATE_DECL. */
552 ;
553 else if (class_template_depth)
554 /* We rely on tsubst_friend_function to check the
555 validity of the declaration later. */
556 decl = push_template_decl_real (decl, /*is_friend=*/true);
557 else
558 decl = check_classfn (ctype, decl,
559 template_member_p
560 ? current_template_parms
561 : NULL_TREE);
562
563 if ((template_member_p
564 /* Always pull out the TEMPLATE_DECL if we have a friend
565 template in a class template so that it gets tsubsted
566 properly later on (59956). tsubst_friend_function knows
567 how to tell this apart from a member template. */
568 || (class_template_depth && friend_depth))
569 && decl && TREE_CODE (decl) == FUNCTION_DECL)
570 decl = DECL_TI_TEMPLATE (decl);
571
572 if (decl)
573 add_friend (current_class_type, decl, /*complain=*/true);
574 }
575 else
576 error ("member %qD declared as friend before type %qT defined",
577 decl, ctype);
578 }
579 /* A global friend.
580 @@ or possibly a friend from a base class ?!? */
581 else if (TREE_CODE (decl) == FUNCTION_DECL)
582 {
583 int is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P ();
584
585 /* Friends must all go through the overload machinery,
586 even though they may not technically be overloaded.
587
588 Note that because classes all wind up being top-level
589 in their scope, their friend wind up in top-level scope as well. */
590 if (funcdef_flag)
591 SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
592
593 if (! DECL_USE_TEMPLATE (decl))
594 {
595 /* We must check whether the decl refers to template
596 arguments before push_template_decl_real adds a
597 reference to the containing template class. */
598 int warn = (warn_nontemplate_friend
599 && ! funcdef_flag && ! is_friend_template
600 && current_template_parms
601 && uses_template_parms (decl));
602
603 if (is_friend_template
604 || template_class_depth (current_class_type) != 0)
605 /* We can't call pushdecl for a template class, since in
606 general, such a declaration depends on template
607 parameters. Instead, we call pushdecl when the class
608 is instantiated. */
609 decl = push_template_decl_real (decl, /*is_friend=*/true);
610 else if (current_function_decl)
611 /* pushdecl will check there's a local decl already. */
612 decl = pushdecl (decl, /*is_friend=*/true);
613 else
614 {
615 /* We can't use pushdecl, as we might be in a template
616 class specialization, and pushdecl will insert an
617 unqualified friend decl into the template parameter
618 scope, rather than the namespace containing it. */
619 tree ns = decl_namespace_context (decl);
620
621 push_nested_namespace (ns);
622 decl = pushdecl_namespace_level (decl, /*is_friend=*/true);
623 pop_nested_namespace (ns);
624 }
625
626 if (warn)
627 {
628 static int explained;
629 bool warned;
630
631 warned = warning (OPT_Wnon_template_friend, "friend declaration "
632 "%q#D declares a non-template function", decl);
633 if (! explained && warned)
634 {
635 inform (input_location, "(if this is not what you intended, make sure "
636 "the function template has already been declared "
637 "and add <> after the function name here) ");
638 explained = 1;
639 }
640 }
641 }
642
643 if (decl == error_mark_node)
644 return error_mark_node;
645
646 add_friend (current_class_type,
647 is_friend_template ? DECL_TI_TEMPLATE (decl) : decl,
648 /*complain=*/true);
649 DECL_FRIEND_P (decl) = 1;
650 }
651
652 return decl;
653}
654
655#include "gt-cp-friend.h"
656