1 /* Help friends in C++.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2007, 2008, 2010 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"
30 /* Friend data structures are described in cp-tree.h. */
32 /* Returns nonzero if SUPPLICANT is a friend of TYPE. */
35 is_friend (tree type
, tree supplicant
)
41 if (supplicant
== NULL_TREE
|| type
== NULL_TREE
)
44 declp
= DECL_P (supplicant
);
47 /* It's a function decl. */
49 tree list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
));
50 tree name
= DECL_NAME (supplicant
);
52 for (; list
; list
= TREE_CHAIN (list
))
54 if (name
== FRIEND_NAME (list
))
56 tree friends
= FRIEND_DECLS (list
);
57 for (; friends
; friends
= TREE_CHAIN (friends
))
59 tree this_friend
= TREE_VALUE (friends
);
61 if (this_friend
== NULL_TREE
)
64 if (supplicant
== this_friend
)
67 if (is_specialization_of_friend (supplicant
, this_friend
))
77 if (same_type_p (supplicant
, type
))
80 list
= CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type
)));
81 for (; list
; list
= TREE_CHAIN (list
))
83 tree t
= TREE_VALUE (list
);
85 if (TREE_CODE (t
) == TEMPLATE_DECL
?
86 is_specialization_of_friend (TYPE_MAIN_DECL (supplicant
), t
) :
87 same_type_p (supplicant
, t
))
94 if (DECL_FUNCTION_MEMBER_P (supplicant
))
95 context
= DECL_CONTEXT (supplicant
);
101 if (TYPE_CLASS_SCOPE_P (supplicant
))
102 /* Nested classes get the same access as their enclosing types, as
103 per DR 45 (this is a change from the standard). */
104 context
= TYPE_CONTEXT (supplicant
);
106 /* Local classes have the same access as the enclosing function. */
107 context
= decl_function_context (TYPE_MAIN_DECL (supplicant
));
110 /* A namespace is not friend to anybody. */
111 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
115 return is_friend (type
, context
);
120 /* Add a new friend to the friends of the aggregate type TYPE.
121 DECL is the FUNCTION_DECL of the friend being added.
123 If COMPLAIN is true, warning about duplicate friend is issued.
124 We want to have this diagnostics during parsing but not
125 when a template is being instantiated. */
128 add_friend (tree type
, tree decl
, bool complain
)
135 if (decl
== error_mark_node
)
138 typedecl
= TYPE_MAIN_DECL (type
);
139 list
= DECL_FRIENDLIST (typedecl
);
140 name
= DECL_NAME (decl
);
141 type
= TREE_TYPE (typedecl
);
145 if (name
== FRIEND_NAME (list
))
147 tree friends
= FRIEND_DECLS (list
);
148 for (; friends
; friends
= TREE_CHAIN (friends
))
150 if (decl
== TREE_VALUE (friends
))
153 warning (0, "%qD is already a friend of class %qT",
159 maybe_add_class_template_decl_list (type
, decl
, /*friend_p=*/1);
161 TREE_VALUE (list
) = tree_cons (NULL_TREE
, decl
,
165 list
= TREE_CHAIN (list
);
168 ctx
= DECL_CONTEXT (decl
);
169 if (ctx
&& CLASS_TYPE_P (ctx
) && !uses_template_parms (ctx
))
170 perform_or_defer_access_check (TYPE_BINFO (ctx
), decl
, decl
);
172 maybe_add_class_template_decl_list (type
, decl
, /*friend_p=*/1);
174 DECL_FRIENDLIST (typedecl
)
175 = tree_cons (DECL_NAME (decl
), build_tree_list (NULL_TREE
, decl
),
176 DECL_FRIENDLIST (typedecl
));
177 if (!uses_template_parms (type
))
178 DECL_BEFRIENDING_CLASSES (decl
)
179 = tree_cons (NULL_TREE
, type
,
180 DECL_BEFRIENDING_CLASSES (decl
));
183 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already
184 been defined, we make all of its member functions friends of
185 TYPE. If not, we make it a pending friend, which can later be added
186 when its definition is seen. If a type is defined, then its TYPE_DECL's
187 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
188 classes that are not defined. If a type has not yet been defined,
189 then the DECL_WAITING_FRIENDS contains a list of types
190 waiting to make it their friend. Note that these two can both
191 be in use at the same time!
193 If COMPLAIN is true, warning about duplicate friend is issued.
194 We want to have this diagnostics during parsing but not
195 when a template is being instantiated. */
198 make_friend_class (tree type
, tree friend_type
, bool complain
)
202 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
203 the enclosing class. FRIEND_DEPTH counts the number of template
204 headers used for this friend declaration. TEMPLATE_MEMBER_P,
205 defined inside the `if' block for TYPENAME_TYPE case, is true if
206 a template header in FRIEND_DEPTH is intended for DECLARATOR.
207 For example, the code
209 template <class T> struct A {
210 template <class U> struct B {
211 template <class V> template <class W>
212 friend class C<V>::D;
216 will eventually give the following results
218 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
219 2. FRIEND_DEPTH equals 2 (for `V' and `W').
220 3. TEMPLATE_MEMBER_P is true (for `W').
222 The friend is a template friend iff FRIEND_DEPTH is nonzero. */
224 int class_template_depth
= template_class_depth (type
);
225 int friend_depth
= processing_template_decl
- class_template_depth
;
227 if (! MAYBE_CLASS_TYPE_P (friend_type
))
229 error ("invalid type %qT declared %<friend%>", friend_type
);
234 /* If the TYPE is a template then it makes sense for it to be
235 friends with itself; this means that each instantiation is
236 friends with all other instantiations. */
238 if (CLASS_TYPE_P (friend_type
)
239 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type
)
240 && uses_template_parms (friend_type
))
243 Friend declarations shall not declare partial
245 error ("partial specialization %qT declared %<friend%>",
250 else if (same_type_p (type
, friend_type
))
253 warning (0, "class %qT is implicitly friends with itself",
260 A friend of a class or class template can be a function or
261 class template, a specialization of a function template or
262 class template, or an ordinary (nontemplate) function or
266 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
)
268 if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type
))
271 /* template <class U> friend class T::X<U>; */
273 Friend declarations shall not declare partial
275 error ("partial specialization %qT declared %<friend%>",
281 /* We will figure this out later. */
282 bool template_member_p
= false;
284 tree ctype
= TYPE_CONTEXT (friend_type
);
285 tree name
= TYPE_IDENTIFIER (friend_type
);
288 if (!uses_template_parms_level (ctype
, class_template_depth
290 template_member_p
= true;
292 if (class_template_depth
)
294 /* We rely on tsubst_friend_class to check the
295 validity of the declaration later. */
296 if (template_member_p
)
298 = make_unbound_class_template (ctype
,
300 current_template_parms
,
304 = make_typename_type (ctype
, name
, class_type
, tf_error
);
308 decl
= lookup_member (ctype
, name
, 0, true);
311 error ("%qT is not a member of %qT", name
, ctype
);
314 if (template_member_p
&& !DECL_CLASS_TEMPLATE_P (decl
))
316 error ("%qT is not a member class template of %qT",
318 error ("%q+D declared here", decl
);
321 if (!template_member_p
&& (TREE_CODE (decl
) != TYPE_DECL
322 || !CLASS_TYPE_P (TREE_TYPE (decl
))))
324 error ("%qT is not a nested class of %qT",
326 error ("%q+D declared here", decl
);
330 friend_type
= CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
));
334 else if (TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
336 /* template <class T> friend class T; */
337 error ("template parameter type %qT declared %<friend%>", friend_type
);
340 else if (!CLASSTYPE_TEMPLATE_INFO (friend_type
))
342 /* template <class T> friend class A; where A is not a template */
343 error ("%q#T is not a template", friend_type
);
347 /* template <class T> friend class A; where A is a template */
348 friend_type
= CLASSTYPE_TI_TEMPLATE (friend_type
);
350 if (friend_type
== error_mark_node
)
353 /* See if it is already a friend. */
354 for (classes
= CLASSTYPE_FRIEND_CLASSES (type
);
356 classes
= TREE_CHAIN (classes
))
358 tree probe
= TREE_VALUE (classes
);
360 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
362 if (friend_type
== probe
)
365 warning (0, "%qD is already a friend of %qT", probe
, type
);
369 else if (TREE_CODE (probe
) != TEMPLATE_DECL
)
371 if (same_type_p (probe
, friend_type
))
374 warning (0, "%qT is already a friend of %qT", probe
, type
);
382 maybe_add_class_template_decl_list (type
, friend_type
, /*friend_p=*/1);
384 CLASSTYPE_FRIEND_CLASSES (type
)
385 = tree_cons (NULL_TREE
, friend_type
, CLASSTYPE_FRIEND_CLASSES (type
));
386 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
387 friend_type
= TREE_TYPE (friend_type
);
388 if (!uses_template_parms (type
))
389 CLASSTYPE_BEFRIENDING_CLASSES (friend_type
)
390 = tree_cons (NULL_TREE
, type
,
391 CLASSTYPE_BEFRIENDING_CLASSES (friend_type
));
395 /* Record DECL (a FUNCTION_DECL) as a friend of the
396 CURRENT_CLASS_TYPE. If DECL is a member function, CTYPE is the
397 class of which it is a member, as named in the friend declaration.
398 DECLARATOR is the name of the friend. FUNCDEF_FLAG is true if the
399 friend declaration is a definition of the function. FLAGS is as
403 do_friend (tree ctype
, tree declarator
, tree decl
,
404 tree attrlist
, enum overload_flags flags
,
407 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
408 gcc_assert (!ctype
|| MAYBE_CLASS_TYPE_P (ctype
));
410 /* Every decl that gets here is a friend of something. */
411 DECL_FRIEND_P (decl
) = 1;
413 /* Unfortunately, we have to handle attributes here. Normally we would
414 handle them in start_decl_1, but since this is a friend decl start_decl_1
415 never gets to see it. */
417 /* Set attributes here so if duplicate decl, will have proper attributes. */
418 cplus_decl_attributes (&decl
, attrlist
, 0);
420 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
422 declarator
= TREE_OPERAND (declarator
, 0);
423 if (is_overloaded_fn (declarator
))
424 declarator
= DECL_NAME (get_first_fn (declarator
));
429 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
430 the enclosing class. FRIEND_DEPTH counts the number of template
431 headers used for this friend declaration. TEMPLATE_MEMBER_P is
432 true if a template header in FRIEND_DEPTH is intended for
433 DECLARATOR. For example, the code
435 template <class T> struct A {
436 template <class U> struct B {
437 template <class V> template <class W>
438 friend void C<V>::f(W);
442 will eventually give the following results
444 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
445 2. FRIEND_DEPTH equals 2 (for `V' and `W').
446 3. TEMPLATE_MEMBER_P is true (for `W'). */
448 int class_template_depth
= template_class_depth (current_class_type
);
449 int friend_depth
= processing_template_decl
- class_template_depth
;
450 /* We will figure this out later. */
451 bool template_member_p
= false;
453 tree cname
= TYPE_NAME (ctype
);
454 if (TREE_CODE (cname
) == TYPE_DECL
)
455 cname
= DECL_NAME (cname
);
457 /* A method friend. */
458 if (flags
== NO_SPECIAL
&& declarator
== cname
)
459 DECL_CONSTRUCTOR_P (decl
) = 1;
461 grokclassfn (ctype
, decl
, flags
);
465 if (!uses_template_parms_level (ctype
, class_template_depth
467 template_member_p
= true;
470 /* A nested class may declare a member of an enclosing class
471 to be a friend, so we do lookup here even if CTYPE is in
472 the process of being defined. */
473 if (class_template_depth
474 || COMPLETE_TYPE_P (ctype
)
475 || (CLASS_TYPE_P (ctype
) && TYPE_BEING_DEFINED (ctype
)))
477 if (DECL_TEMPLATE_INFO (decl
))
478 /* DECL is a template specialization. No need to
479 build a new TEMPLATE_DECL. */
481 else if (class_template_depth
)
482 /* We rely on tsubst_friend_function to check the
483 validity of the declaration later. */
484 decl
= push_template_decl_real (decl
, /*is_friend=*/true);
486 decl
= check_classfn (ctype
, decl
,
488 ? current_template_parms
491 if (template_member_p
&& decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
492 decl
= DECL_TI_TEMPLATE (decl
);
495 add_friend (current_class_type
, decl
, /*complain=*/true);
498 error ("member %qD declared as friend before type %qT defined",
502 @@ or possibly a friend from a base class ?!? */
503 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
505 int is_friend_template
= PROCESSING_REAL_TEMPLATE_DECL_P ();
507 /* Friends must all go through the overload machinery,
508 even though they may not technically be overloaded.
510 Note that because classes all wind up being top-level
511 in their scope, their friend wind up in top-level scope as well. */
513 SET_DECL_FRIEND_CONTEXT (decl
, current_class_type
);
515 if (! DECL_USE_TEMPLATE (decl
))
517 /* We must check whether the decl refers to template
518 arguments before push_template_decl_real adds a
519 reference to the containing template class. */
520 int warn
= (warn_nontemplate_friend
521 && ! funcdef_flag
&& ! is_friend_template
522 && current_template_parms
523 && uses_template_parms (decl
));
525 if (is_friend_template
526 || template_class_depth (current_class_type
) != 0)
527 /* We can't call pushdecl for a template class, since in
528 general, such a declaration depends on template
529 parameters. Instead, we call pushdecl when the class
531 decl
= push_template_decl_real (decl
, /*is_friend=*/true);
532 else if (current_function_decl
)
534 /* This must be a local class. 11.5p11:
536 If a friend declaration appears in a local class (9.8) and
537 the name specified is an unqualified name, a prior
538 declaration is looked up without considering scopes that
539 are outside the innermost enclosing non-class scope. For a
540 friend function declaration, if there is no prior
541 declaration, the program is ill-formed. */
542 tree t
= lookup_name_innermost_nonclass_level (DECL_NAME (decl
));
544 decl
= pushdecl_maybe_friend (decl
, /*is_friend=*/true);
547 error ("friend declaration %qD in local class without "
548 "prior declaration", decl
);
549 return error_mark_node
;
554 /* We can't use pushdecl, as we might be in a template
555 class specialization, and pushdecl will insert an
556 unqualified friend decl into the template parameter
557 scope, rather than the namespace containing it. */
558 tree ns
= decl_namespace_context (decl
);
560 push_nested_namespace (ns
);
561 decl
= pushdecl_namespace_level (decl
, /*is_friend=*/true);
562 pop_nested_namespace (ns
);
567 static int explained
;
570 warned
= warning (OPT_Wnon_template_friend
, "friend declaration "
571 "%q#D declares a non-template function", decl
);
572 if (! explained
&& warned
)
574 inform (input_location
, "(if this is not what you intended, make sure "
575 "the function template has already been declared "
576 "and add <> after the function name here) ");
582 if (decl
== error_mark_node
)
583 return error_mark_node
;
585 add_friend (current_class_type
,
586 is_friend_template
? DECL_TI_TEMPLATE (decl
) : decl
,
588 DECL_FRIEND_P (decl
) = 1;