1 /* Help friends in C++.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2007, 2008 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
33 /* Friend data structures are described in cp-tree.h. */
35 /* Returns nonzero if SUPPLICANT is a friend of TYPE. */
38 is_friend (tree type
, tree supplicant
)
44 if (supplicant
== NULL_TREE
|| type
== NULL_TREE
)
47 declp
= DECL_P (supplicant
);
50 /* It's a function decl. */
52 tree list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
));
53 tree name
= DECL_NAME (supplicant
);
55 for (; list
; list
= TREE_CHAIN (list
))
57 if (name
== FRIEND_NAME (list
))
59 tree friends
= FRIEND_DECLS (list
);
60 for (; friends
; friends
= TREE_CHAIN (friends
))
62 tree
friend = TREE_VALUE (friends
);
64 if (friend == NULL_TREE
)
67 if (supplicant
== friend)
70 if (is_specialization_of_friend (supplicant
, friend))
80 if (same_type_p (supplicant
, type
))
83 list
= CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type
)));
84 for (; list
; list
= TREE_CHAIN (list
))
86 tree t
= TREE_VALUE (list
);
88 if (TREE_CODE (t
) == TEMPLATE_DECL
?
89 is_specialization_of_friend (TYPE_MAIN_DECL (supplicant
), t
) :
90 same_type_p (supplicant
, t
))
97 if (DECL_FUNCTION_MEMBER_P (supplicant
))
98 context
= DECL_CONTEXT (supplicant
);
104 if (TYPE_CLASS_SCOPE_P (supplicant
))
105 /* Nested classes get the same access as their enclosing types, as
106 per DR 45 (this is a change from the standard). */
107 context
= TYPE_CONTEXT (supplicant
);
109 /* Local classes have the same access as the enclosing function. */
110 context
= decl_function_context (TYPE_MAIN_DECL (supplicant
));
113 /* A namespace is not friend to anybody. */
114 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
118 return is_friend (type
, context
);
123 /* Add a new friend to the friends of the aggregate type TYPE.
124 DECL is the FUNCTION_DECL of the friend being added.
126 If COMPLAIN is true, warning about duplicate friend is issued.
127 We want to have this diagnostics during parsing but not
128 when a template is being instantiated. */
131 add_friend (tree type
, tree decl
, bool complain
)
138 if (decl
== error_mark_node
)
141 typedecl
= TYPE_MAIN_DECL (type
);
142 list
= DECL_FRIENDLIST (typedecl
);
143 name
= DECL_NAME (decl
);
144 type
= TREE_TYPE (typedecl
);
148 if (name
== FRIEND_NAME (list
))
150 tree friends
= FRIEND_DECLS (list
);
151 for (; friends
; friends
= TREE_CHAIN (friends
))
153 if (decl
== TREE_VALUE (friends
))
156 warning (0, "%qD is already a friend of class %qT",
162 maybe_add_class_template_decl_list (type
, decl
, /*friend_p=*/1);
164 TREE_VALUE (list
) = tree_cons (NULL_TREE
, decl
,
168 list
= TREE_CHAIN (list
);
171 ctx
= DECL_CONTEXT (decl
);
172 if (ctx
&& CLASS_TYPE_P (ctx
) && !uses_template_parms (ctx
))
173 perform_or_defer_access_check (TYPE_BINFO (ctx
), decl
, decl
);
175 maybe_add_class_template_decl_list (type
, decl
, /*friend_p=*/1);
177 DECL_FRIENDLIST (typedecl
)
178 = tree_cons (DECL_NAME (decl
), build_tree_list (NULL_TREE
, decl
),
179 DECL_FRIENDLIST (typedecl
));
180 if (!uses_template_parms (type
))
181 DECL_BEFRIENDING_CLASSES (decl
)
182 = tree_cons (NULL_TREE
, type
,
183 DECL_BEFRIENDING_CLASSES (decl
));
186 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already
187 been defined, we make all of its member functions friends of
188 TYPE. If not, we make it a pending friend, which can later be added
189 when its definition is seen. If a type is defined, then its TYPE_DECL's
190 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
191 classes that are not defined. If a type has not yet been defined,
192 then the DECL_WAITING_FRIENDS contains a list of types
193 waiting to make it their friend. Note that these two can both
194 be in use at the same time!
196 If COMPLAIN is true, warning about duplicate friend is issued.
197 We want to have this diagnostics during parsing but not
198 when a template is being instantiated. */
201 make_friend_class (tree type
, tree friend_type
, bool complain
)
205 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
206 the enclosing class. FRIEND_DEPTH counts the number of template
207 headers used for this friend declaration. TEMPLATE_MEMBER_P,
208 defined inside the `if' block for TYPENAME_TYPE case, is true if
209 a template header in FRIEND_DEPTH is intended for DECLARATOR.
210 For example, the code
212 template <class T> struct A {
213 template <class U> struct B {
214 template <class V> template <class W>
215 friend class C<V>::D;
219 will eventually give the following results
221 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
222 2. FRIEND_DEPTH equals 2 (for `V' and `W').
223 3. TEMPLATE_MEMBER_P is true (for `W').
225 The friend is a template friend iff FRIEND_DEPTH is nonzero. */
227 int class_template_depth
= template_class_depth (type
);
228 int friend_depth
= processing_template_decl
- class_template_depth
;
230 if (! MAYBE_CLASS_TYPE_P (friend_type
))
232 error ("invalid type %qT declared %<friend%>", friend_type
);
237 /* If the TYPE is a template then it makes sense for it to be
238 friends with itself; this means that each instantiation is
239 friends with all other instantiations. */
241 if (CLASS_TYPE_P (friend_type
)
242 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type
)
243 && uses_template_parms (friend_type
))
246 Friend declarations shall not declare partial
248 error ("partial specialization %qT declared %<friend%>",
253 else if (same_type_p (type
, friend_type
))
256 pedwarn ("class %qT is implicitly friends with itself",
263 A friend of a class or class template can be a function or
264 class template, a specialization of a function template or
265 class template, or an ordinary (nontemplate) function or
269 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
)
271 if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type
))
274 /* template <class U> friend class T::X<U>; */
276 Friend declarations shall not declare partial
278 error ("partial specialization %qT declared %<friend%>",
284 /* We will figure this out later. */
285 bool template_member_p
= false;
287 tree ctype
= TYPE_CONTEXT (friend_type
);
288 tree name
= TYPE_IDENTIFIER (friend_type
);
291 if (!uses_template_parms_level (ctype
, class_template_depth
293 template_member_p
= true;
295 if (class_template_depth
)
297 /* We rely on tsubst_friend_class to check the
298 validity of the declaration later. */
299 if (template_member_p
)
301 = make_unbound_class_template (ctype
,
303 current_template_parms
,
307 = make_typename_type (ctype
, name
, class_type
, tf_error
);
311 decl
= lookup_member (ctype
, name
, 0, true);
314 error ("%qT is not a member of %qT", name
, ctype
);
317 if (template_member_p
&& !DECL_CLASS_TEMPLATE_P (decl
))
319 error ("%qT is not a member class template of %qT",
321 error ("%q+D declared here", decl
);
324 if (!template_member_p
&& (TREE_CODE (decl
) != TYPE_DECL
325 || !CLASS_TYPE_P (TREE_TYPE (decl
))))
327 error ("%qT is not a nested class of %qT",
329 error ("%q+D declared here", decl
);
333 friend_type
= CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
));
337 else if (TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
339 /* template <class T> friend class T; */
340 error ("template parameter type %qT declared %<friend%>", friend_type
);
343 else if (!CLASSTYPE_TEMPLATE_INFO (friend_type
))
345 /* template <class T> friend class A; where A is not a template */
346 error ("%q#T is not a template", friend_type
);
350 /* template <class T> friend class A; where A is a template */
351 friend_type
= CLASSTYPE_TI_TEMPLATE (friend_type
);
353 if (friend_type
== error_mark_node
)
356 /* See if it is already a friend. */
357 for (classes
= CLASSTYPE_FRIEND_CLASSES (type
);
359 classes
= TREE_CHAIN (classes
))
361 tree probe
= TREE_VALUE (classes
);
363 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
365 if (friend_type
== probe
)
368 warning (0, "%qD is already a friend of %qT", probe
, type
);
372 else if (TREE_CODE (probe
) != TEMPLATE_DECL
)
374 if (same_type_p (probe
, friend_type
))
377 warning (0, "%qT is already a friend of %qT", probe
, type
);
385 maybe_add_class_template_decl_list (type
, friend_type
, /*friend_p=*/1);
387 CLASSTYPE_FRIEND_CLASSES (type
)
388 = tree_cons (NULL_TREE
, friend_type
, CLASSTYPE_FRIEND_CLASSES (type
));
389 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
390 friend_type
= TREE_TYPE (friend_type
);
391 if (!uses_template_parms (type
))
392 CLASSTYPE_BEFRIENDING_CLASSES (friend_type
)
393 = tree_cons (NULL_TREE
, type
,
394 CLASSTYPE_BEFRIENDING_CLASSES (friend_type
));
398 /* Record DECL (a FUNCTION_DECL) as a friend of the
399 CURRENT_CLASS_TYPE. If DECL is a member function, CTYPE is the
400 class of which it is a member, as named in the friend declaration.
401 DECLARATOR is the name of the friend. FUNCDEF_FLAG is true if the
402 friend declaration is a definition of the function. FLAGS is as
406 do_friend (tree ctype
, tree declarator
, tree decl
,
407 tree attrlist
, enum overload_flags flags
,
410 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
411 gcc_assert (!ctype
|| MAYBE_CLASS_TYPE_P (ctype
));
413 /* Every decl that gets here is a friend of something. */
414 DECL_FRIEND_P (decl
) = 1;
416 /* Unfortunately, we have to handle attributes here. Normally we would
417 handle them in start_decl_1, but since this is a friend decl start_decl_1
418 never gets to see it. */
420 /* Set attributes here so if duplicate decl, will have proper attributes. */
421 cplus_decl_attributes (&decl
, attrlist
, 0);
423 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
425 declarator
= TREE_OPERAND (declarator
, 0);
426 if (is_overloaded_fn (declarator
))
427 declarator
= DECL_NAME (get_first_fn (declarator
));
432 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
433 the enclosing class. FRIEND_DEPTH counts the number of template
434 headers used for this friend declaration. TEMPLATE_MEMBER_P is
435 true if a template header in FRIEND_DEPTH is intended for
436 DECLARATOR. For example, the code
438 template <class T> struct A {
439 template <class U> struct B {
440 template <class V> template <class W>
441 friend void C<V>::f(W);
445 will eventually give the following results
447 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
448 2. FRIEND_DEPTH equals 2 (for `V' and `W').
449 3. TEMPLATE_MEMBER_P is true (for `W'). */
451 int class_template_depth
= template_class_depth (current_class_type
);
452 int friend_depth
= processing_template_decl
- class_template_depth
;
453 /* We will figure this out later. */
454 bool template_member_p
= false;
456 tree cname
= TYPE_NAME (ctype
);
457 if (TREE_CODE (cname
) == TYPE_DECL
)
458 cname
= DECL_NAME (cname
);
460 /* A method friend. */
461 if (flags
== NO_SPECIAL
&& declarator
== cname
)
462 DECL_CONSTRUCTOR_P (decl
) = 1;
464 grokclassfn (ctype
, decl
, flags
);
468 if (!uses_template_parms_level (ctype
, class_template_depth
470 template_member_p
= true;
473 /* A nested class may declare a member of an enclosing class
474 to be a friend, so we do lookup here even if CTYPE is in
475 the process of being defined. */
476 if (class_template_depth
477 || COMPLETE_TYPE_P (ctype
)
478 || (CLASS_TYPE_P (ctype
) && TYPE_BEING_DEFINED (ctype
)))
480 if (DECL_TEMPLATE_INFO (decl
))
481 /* DECL is a template specialization. No need to
482 build a new TEMPLATE_DECL. */
484 else if (class_template_depth
)
485 /* We rely on tsubst_friend_function to check the
486 validity of the declaration later. */
487 decl
= push_template_decl_real (decl
, /*is_friend=*/true);
489 decl
= check_classfn (ctype
, decl
,
491 ? current_template_parms
494 if (template_member_p
&& decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
495 decl
= DECL_TI_TEMPLATE (decl
);
498 add_friend (current_class_type
, decl
, /*complain=*/true);
501 error ("member %qD declared as friend before type %qT defined",
505 @@ or possibly a friend from a base class ?!? */
506 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
508 int is_friend_template
= PROCESSING_REAL_TEMPLATE_DECL_P ();
510 /* Friends must all go through the overload machinery,
511 even though they may not technically be overloaded.
513 Note that because classes all wind up being top-level
514 in their scope, their friend wind up in top-level scope as well. */
516 SET_DECL_FRIEND_CONTEXT (decl
, current_class_type
);
518 if (! DECL_USE_TEMPLATE (decl
))
520 /* We must check whether the decl refers to template
521 arguments before push_template_decl_real adds a
522 reference to the containing template class. */
523 int warn
= (warn_nontemplate_friend
524 && ! funcdef_flag
&& ! is_friend_template
525 && current_template_parms
526 && uses_template_parms (decl
));
528 if (is_friend_template
529 || template_class_depth (current_class_type
) != 0)
530 /* We can't call pushdecl for a template class, since in
531 general, such a declaration depends on template
532 parameters. Instead, we call pushdecl when the class
534 decl
= push_template_decl_real (decl
, /*is_friend=*/true);
535 else if (current_function_decl
)
537 /* This must be a local class. 11.5p11:
539 If a friend declaration appears in a local class (9.8) and
540 the name specified is an unqualified name, a prior
541 declaration is looked up without considering scopes that
542 are outside the innermost enclosing non-class scope. For a
543 friend function declaration, if there is no prior
544 declaration, the program is ill-formed. */
545 tree t
= lookup_name_innermost_nonclass_level (DECL_NAME (decl
));
547 decl
= pushdecl_maybe_friend (decl
, /*is_friend=*/true);
550 error ("friend declaration %qD in local class without "
551 "prior declaration", decl
);
552 return error_mark_node
;
557 /* We can't use pushdecl, as we might be in a template
558 class specialization, and pushdecl will insert an
559 unqualified friend decl into the template parameter
560 scope, rather than the namespace containing it. */
561 tree ns
= decl_namespace_context (decl
);
563 push_nested_namespace (ns
);
564 decl
= pushdecl_namespace_level (decl
, /*is_friend=*/true);
565 pop_nested_namespace (ns
);
570 static int explained
;
571 warning (OPT_Wnon_template_friend
, "friend declaration "
572 "%q#D declares a non-template function", decl
);
575 inform ("(if this is not what you intended, make sure "
576 "the function template has already been declared "
577 "and add <> after the function name here) ");
583 if (decl
== error_mark_node
)
584 return error_mark_node
;
586 add_friend (current_class_type
,
587 is_friend_template
? DECL_TI_TEMPLATE (decl
) : decl
,
589 DECL_FRIEND_P (decl
) = 1;