1 /* Help friends in C++.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 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 2, 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 COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "coretypes.h"
34 /* Friend data structures are described in cp-tree.h. */
36 /* Returns nonzero if SUPPLICANT is a friend of TYPE. */
39 is_friend (tree type, tree supplicant)
45 if (supplicant == NULL_TREE || type == NULL_TREE)
48 declp = DECL_P (supplicant);
51 /* It's a function decl. */
53 tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
54 tree name = DECL_NAME (supplicant);
56 for (; list ; list = TREE_CHAIN (list))
58 if (name == FRIEND_NAME (list))
60 tree friends = FRIEND_DECLS (list);
61 for (; friends ; friends = TREE_CHAIN (friends))
63 tree friend = TREE_VALUE (friends);
65 if (friend == NULL_TREE)
68 if (supplicant == friend)
71 if (is_specialization_of_friend (supplicant, friend))
81 /* Nested classes are implicitly friends of their enclosing types, as
82 per core issue 45 (this is a change from the standard). */
83 for (context = supplicant;
84 context && TYPE_P (context);
85 context = TYPE_CONTEXT (context))
89 list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type)));
90 for (; list ; list = TREE_CHAIN (list))
92 tree t = TREE_VALUE (list);
94 if (TREE_CODE (t) == TEMPLATE_DECL ?
95 is_specialization_of_friend (TYPE_MAIN_DECL (supplicant), t) :
96 same_type_p (supplicant, t))
101 if (declp && DECL_FUNCTION_MEMBER_P (supplicant))
102 context = DECL_CONTEXT (supplicant);
104 /* Local classes have the same access as the enclosing function. */
105 context = decl_function_context (TYPE_MAIN_DECL (supplicant));
109 /* A namespace is not friend to anybody. */
110 if (context && TREE_CODE (context) == NAMESPACE_DECL)
114 return is_friend (type, context);
119 /* Add a new friend to the friends of the aggregate type TYPE.
120 DECL is the FUNCTION_DECL of the friend being added.
122 If COMPLAIN is true, warning about duplicate friend is issued.
123 We want to have this diagnostics during parsing but not
124 when a template is being instantiated. */
127 add_friend (tree type, tree decl, bool complain)
134 if (decl == error_mark_node)
137 typedecl = TYPE_MAIN_DECL (type);
138 list = DECL_FRIENDLIST (typedecl);
139 name = DECL_NAME (decl);
140 type = TREE_TYPE (typedecl);
144 if (name == FRIEND_NAME (list))
146 tree friends = FRIEND_DECLS (list);
147 for (; friends ; friends = TREE_CHAIN (friends))
149 if (decl == TREE_VALUE (friends))
152 warning (0, "%qD is already a friend of class %qT",
158 maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
160 TREE_VALUE (list) = tree_cons (NULL_TREE, decl,
164 list = TREE_CHAIN (list);
167 ctx = DECL_CONTEXT (decl);
168 if (ctx && CLASS_TYPE_P (ctx) && !uses_template_parms (ctx))
169 perform_or_defer_access_check (TYPE_BINFO (ctx), decl);
171 maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
173 DECL_FRIENDLIST (typedecl)
174 = tree_cons (DECL_NAME (decl), build_tree_list (NULL_TREE, decl),
175 DECL_FRIENDLIST (typedecl));
176 if (!uses_template_parms (type))
177 DECL_BEFRIENDING_CLASSES (decl)
178 = tree_cons (NULL_TREE, type,
179 DECL_BEFRIENDING_CLASSES (decl));
182 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already
183 been defined, we make all of its member functions friends of
184 TYPE. If not, we make it a pending friend, which can later be added
185 when its definition is seen. If a type is defined, then its TYPE_DECL's
186 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
187 classes that are not defined. If a type has not yet been defined,
188 then the DECL_WAITING_FRIENDS contains a list of types
189 waiting to make it their friend. Note that these two can both
190 be in use at the same time!
192 If COMPLAIN is true, warning about duplicate friend is issued.
193 We want to have this diagnostics during parsing but not
194 when a template is being instantiated. */
197 make_friend_class (tree type, tree friend_type, bool complain)
201 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
202 the enclosing class. FRIEND_DEPTH counts the number of template
203 headers used for this friend declaration. TEMPLATE_MEMBER_P,
204 defined inside the `if' block for TYPENAME_TYPE case, is true if
205 a template header in FRIEND_DEPTH is intended for DECLARATOR.
206 For example, the code
208 template <class T> struct A {
209 template <class U> struct B {
210 template <class V> template <class W>
211 friend class C<V>::D;
215 will eventually give the following results
217 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
218 2. FRIEND_DEPTH equals 2 (for `V' and `W').
219 3. TEMPLATE_MEMBER_P is true (for `W').
221 The friend is a template friend iff FRIEND_DEPTH is nonzero. */
223 int class_template_depth = template_class_depth (type);
224 int friend_depth = processing_template_decl - class_template_depth;
226 if (! IS_AGGR_TYPE (friend_type))
228 error ("invalid type %qT declared %<friend%>", friend_type);
233 /* If the TYPE is a template then it makes sense for it to be
234 friends with itself; this means that each instantiation is
235 friends with all other instantiations. */
237 if (CLASS_TYPE_P (friend_type)
238 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type)
239 && uses_template_parms (friend_type))
242 Friend declarations shall not declare partial
244 error ("partial specialization %qT declared %<friend%>",
249 else if (same_type_p (type, friend_type))
252 pedwarn ("class %qT is implicitly friends with itself",
259 A friend of a class or class template can be a function or
260 class template, a specialization of a function template or
261 class template, or an ordinary (nontemplate) function or
265 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
267 if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type))
270 /* template <class U> friend class T::X<U>; */
272 Friend declarations shall not declare partial
274 error ("partial specialization %qT declared %<friend%>",
280 /* We will figure this out later. */
281 bool template_member_p = false;
283 tree ctype = TYPE_CONTEXT (friend_type);
284 tree name = TYPE_IDENTIFIER (friend_type);
287 if (!uses_template_parms_level (ctype, class_template_depth
289 template_member_p = true;
291 if (class_template_depth)
293 /* We rely on tsubst_friend_class to check the
294 validity of the declaration later. */
295 if (template_member_p)
297 = make_unbound_class_template (ctype,
299 current_template_parms,
303 = make_typename_type (ctype, name, class_type, tf_error);
307 decl = lookup_member (ctype, name, 0, true);
310 error ("%qT is not a member of %qT", name, ctype);
313 if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl))
315 error ("%qT is not a member class template of %qT",
317 error ("%q+D declared here", decl);
320 if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL
321 || !CLASS_TYPE_P (TREE_TYPE (decl))))
323 error ("%qT is not a nested class of %qT",
325 error ("%q+D declared here", decl);
329 friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl));
333 else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
335 /* template <class T> friend class T; */
336 error ("template parameter type %qT declared %<friend%>", friend_type);
339 else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
341 /* template <class T> friend class A; where A is not a template */
342 error ("%q#T is not a template", friend_type);
346 /* template <class T> friend class A; where A is a template */
347 friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
349 if (friend_type == error_mark_node)
352 /* See if it is already a friend. */
353 for (classes = CLASSTYPE_FRIEND_CLASSES (type);
355 classes = TREE_CHAIN (classes))
357 tree probe = TREE_VALUE (classes);
359 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
361 if (friend_type == probe)
364 warning (0, "%qD is already a friend of %qT", probe, type);
368 else if (TREE_CODE (probe) != TEMPLATE_DECL)
370 if (same_type_p (probe, friend_type))
373 warning (0, "%qT is already a friend of %qT", probe, type);
381 maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1);
383 CLASSTYPE_FRIEND_CLASSES (type)
384 = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
385 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
386 friend_type = TREE_TYPE (friend_type);
387 if (!uses_template_parms (type))
388 CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
389 = tree_cons (NULL_TREE, type,
390 CLASSTYPE_BEFRIENDING_CLASSES (friend_type));
394 /* Main friend processor.
396 CTYPE is the class this friend belongs to.
398 DECLARATOR is the name of the friend.
400 DECL is the FUNCTION_DECL that the friend is.
402 FLAGS is just used for `grokclassfn'. */
405 do_friend (tree ctype, tree declarator, tree decl,
406 tree attrlist, enum overload_flags flags,
409 /* Every decl that gets here is a friend of something. */
410 DECL_FRIEND_P (decl) = 1;
412 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
414 declarator = TREE_OPERAND (declarator, 0);
415 if (is_overloaded_fn (declarator))
416 declarator = DECL_NAME (get_first_fn (declarator));
419 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
423 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
424 the enclosing class. FRIEND_DEPTH counts the number of template
425 headers used for this friend declaration. TEMPLATE_MEMBER_P is
426 true if a template header in FRIEND_DEPTH is intended for
427 DECLARATOR. For example, the code
429 template <class T> struct A {
430 template <class U> struct B {
431 template <class V> template <class W>
432 friend void C<V>::f(W);
436 will eventually give the following results
438 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
439 2. FRIEND_DEPTH equals 2 (for `V' and `W').
440 3. TEMPLATE_MEMBER_P is true (for `W'). */
442 int class_template_depth = template_class_depth (current_class_type);
443 int friend_depth = processing_template_decl - class_template_depth;
444 /* We will figure this out later. */
445 bool template_member_p = false;
447 tree cname = TYPE_NAME (ctype);
448 if (TREE_CODE (cname) == TYPE_DECL)
449 cname = DECL_NAME (cname);
451 /* A method friend. */
452 if (flags == NO_SPECIAL && declarator == cname)
453 DECL_CONSTRUCTOR_P (decl) = 1;
455 grokclassfn (ctype, decl, flags);
459 if (!uses_template_parms_level (ctype, class_template_depth
461 template_member_p = true;
464 /* A nested class may declare a member of an enclosing class
465 to be a friend, so we do lookup here even if CTYPE is in
466 the process of being defined. */
467 if (class_template_depth
468 || COMPLETE_TYPE_P (ctype)
469 || TYPE_BEING_DEFINED (ctype))
471 if (DECL_TEMPLATE_INFO (decl))
472 /* DECL is a template specialization. No need to
473 build a new TEMPLATE_DECL. */
475 else if (class_template_depth)
476 /* We rely on tsubst_friend_function to check the
477 validity of the declaration later. */
478 decl = push_template_decl_real (decl, /*is_friend=*/true);
480 decl = check_classfn (ctype, decl,
482 ? current_template_parms
485 if (template_member_p && decl && TREE_CODE (decl) == FUNCTION_DECL)
486 decl = DECL_TI_TEMPLATE (decl);
489 add_friend (current_class_type, decl, /*complain=*/true);
492 error ("member %qD declared as friend before type %qT defined",
496 @@ or possibly a friend from a base class ?!? */
497 else if (TREE_CODE (decl) == FUNCTION_DECL)
499 int is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P ();
501 /* Friends must all go through the overload machinery,
502 even though they may not technically be overloaded.
504 Note that because classes all wind up being top-level
505 in their scope, their friend wind up in top-level scope as well. */
507 SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
509 if (! DECL_USE_TEMPLATE (decl))
511 /* We must check whether the decl refers to template
512 arguments before push_template_decl_real adds a
513 reference to the containing template class. */
514 int warn = (warn_nontemplate_friend
515 && ! funcdef_flag && ! is_friend_template
516 && current_template_parms
517 && uses_template_parms (decl));
519 if (is_friend_template
520 || template_class_depth (current_class_type) != 0)
521 /* We can't call pushdecl for a template class, since in
522 general, such a declaration depends on template
523 parameters. Instead, we call pushdecl when the class
525 decl = push_template_decl_real (decl, /*is_friend=*/true);
526 else if (current_function_decl)
527 /* This must be a local class, so pushdecl will be ok, and
528 insert an unqualified friend into the local scope
529 (rather than the containing namespace scope, which the
530 next choice will do). */
531 decl = pushdecl_maybe_friend (decl, /*is_friend=*/true);
534 /* We can't use pushdecl, as we might be in a template
535 class specialization, and pushdecl will insert an
536 unqualified friend decl into the template parameter
537 scope, rather than the namespace containing it. */
538 tree ns = decl_namespace_context (decl);
540 push_nested_namespace (ns);
541 decl = pushdecl_namespace_level (decl, /*is_friend=*/true);
542 pop_nested_namespace (ns);
547 static int explained;
548 warning (0, "friend declaration %q#D declares a non-template "
552 warning (0, "(if this is not what you intended, make sure "
553 "the function template has already been declared "
554 "and add <> after the function name here) "
555 "-Wno-non-template-friend disables this warning");
561 if (decl == error_mark_node)
562 return error_mark_node;
564 add_friend (current_class_type,
565 is_friend_template ? DECL_TI_TEMPLATE (decl) : decl,
567 DECL_FRIEND_P (decl) = 1;
570 /* Unfortunately, we have to handle attributes here. Normally we would
571 handle them in start_decl_1, but since this is a friend decl start_decl_1
572 never gets to see it. */
574 /* Set attributes here so if duplicate decl, will have proper attributes. */
575 cplus_decl_attributes (&decl, attrlist, 0);