1 /* Help friends in C++.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
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, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, 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 (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 ("`%D' is already a friend of class `%T'",
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
)
200 int is_template_friend
;
202 if (! IS_AGGR_TYPE (friend_type
))
204 error ("invalid type `%T' declared `friend'", friend_type
);
208 if (processing_template_decl
> template_class_depth (type
))
209 /* If the TYPE is a template then it makes sense for it to be
210 friends with itself; this means that each instantiation is
211 friends with all other instantiations. */
213 if (CLASS_TYPE_P (friend_type
)
214 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type
)
215 && uses_template_parms (friend_type
))
218 Friend declarations shall not declare partial
220 error ("partial specialization `%T' declared `friend'",
225 is_template_friend
= 1;
227 else if (same_type_p (type
, friend_type
))
230 pedwarn ("class `%T' is implicitly friends with itself",
235 is_template_friend
= 0;
239 A friend of a class or class template can be a function or
240 class template, a specialization of a function template or
241 class template, or an ordinary (nontemplate) function or
243 if (!is_template_friend
)
245 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
)
247 /* template <class T> friend typename S<T>::X; */
248 error ("typename type `%#T' declared `friend'", friend_type
);
251 else if (TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
253 /* template <class T> friend class T; */
254 error ("template parameter type `%T' declared `friend'", friend_type
);
257 else if (!CLASSTYPE_TEMPLATE_INFO (friend_type
))
259 /* template <class T> friend class A; where A is not a template */
260 error ("`%#T' is not a template", friend_type
);
264 if (is_template_friend
)
265 friend_type
= CLASSTYPE_TI_TEMPLATE (friend_type
);
267 /* See if it is already a friend. */
268 for (classes
= CLASSTYPE_FRIEND_CLASSES (type
);
270 classes
= TREE_CHAIN (classes
))
272 tree probe
= TREE_VALUE (classes
);
274 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
276 if (friend_type
== probe
)
279 warning ("`%D' is already a friend of `%T'",
284 else if (TREE_CODE (probe
) != TEMPLATE_DECL
)
286 if (same_type_p (probe
, friend_type
))
289 warning ("`%T' is already a friend of `%T'",
298 maybe_add_class_template_decl_list (type
, friend_type
, /*friend_p=*/1);
300 CLASSTYPE_FRIEND_CLASSES (type
)
301 = tree_cons (NULL_TREE
, friend_type
, CLASSTYPE_FRIEND_CLASSES (type
));
302 if (is_template_friend
)
303 friend_type
= TREE_TYPE (friend_type
);
304 if (!uses_template_parms (type
))
305 CLASSTYPE_BEFRIENDING_CLASSES (friend_type
)
306 = tree_cons (NULL_TREE
, type
,
307 CLASSTYPE_BEFRIENDING_CLASSES (friend_type
));
311 /* Main friend processor.
313 CTYPE is the class this friend belongs to.
315 DECLARATOR is the name of the friend.
317 DECL is the FUNCTION_DECL that the friend is.
319 FLAGS is just used for `grokclassfn'.
321 QUALS say what special qualifies should apply to the object
322 pointed to by `this'. */
325 do_friend (tree ctype
, tree declarator
, tree decl
,
326 tree attrlist
, enum overload_flags flags
,
330 /* Every decl that gets here is a friend of something. */
331 DECL_FRIEND_P (decl
) = 1;
333 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
335 declarator
= TREE_OPERAND (declarator
, 0);
336 if (is_overloaded_fn (declarator
))
337 declarator
= DECL_NAME (get_first_fn (declarator
));
340 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
344 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
345 the enclosing class. FRIEND_DEPTH counts the number of template
346 headers used for this friend declaration. TEMPLATE_MEMBER_P is
347 true if a template header in FRIEND_DEPTH is intended for
348 DECLARATOR. For example, the code
350 template <class T> struct A {
351 template <class U> struct B {
352 template <class V> template <class W>
353 friend void C<V>::f(W);
357 will eventually give the following results
359 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
360 2. FRIEND_DEPTH equals 2 (for `V' and `W').
361 3. TEMPLATE_MEMBER_P is true (for `W'). */
363 int class_template_depth
= template_class_depth (current_class_type
);
364 int friend_depth
= processing_template_decl
- class_template_depth
;
365 /* We will figure this out later. */
366 bool template_member_p
= false;
368 tree cname
= TYPE_NAME (ctype
);
369 if (TREE_CODE (cname
) == TYPE_DECL
)
370 cname
= DECL_NAME (cname
);
372 /* A method friend. */
373 if (flags
== NO_SPECIAL
&& declarator
== cname
)
374 DECL_CONSTRUCTOR_P (decl
) = 1;
376 /* This will set up DECL_ARGUMENTS for us. */
377 grokclassfn (ctype
, decl
, flags
, quals
);
381 if (!uses_template_parms_level (ctype
, class_template_depth
383 template_member_p
= true;
386 /* A nested class may declare a member of an enclosing class
387 to be a friend, so we do lookup here even if CTYPE is in
388 the process of being defined. */
389 if (class_template_depth
390 || COMPLETE_TYPE_P (ctype
)
391 || TYPE_BEING_DEFINED (ctype
))
393 if (DECL_TEMPLATE_INFO (decl
))
394 /* DECL is a template specialization. No need to
395 build a new TEMPLATE_DECL. */
397 else if (class_template_depth
)
398 /* We rely on tsubst_friend_function to check the
399 validity of the declaration later. */
400 decl
= push_template_decl_real (decl
, /*is_friend=*/1);
402 decl
= check_classfn (ctype
, decl
,
404 ? current_template_parms
407 if (template_member_p
&& decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
408 decl
= DECL_TI_TEMPLATE (decl
);
411 add_friend (current_class_type
, decl
, /*complain=*/true);
414 error ("member `%D' declared as friend before type `%T' defined",
418 @@ or possibly a friend from a base class ?!? */
419 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
421 int is_friend_template
= PROCESSING_REAL_TEMPLATE_DECL_P ();
423 /* Friends must all go through the overload machinery,
424 even though they may not technically be overloaded.
426 Note that because classes all wind up being top-level
427 in their scope, their friend wind up in top-level scope as well. */
429 SET_DECL_FRIEND_CONTEXT (decl
, current_class_type
);
431 if (! DECL_USE_TEMPLATE (decl
))
433 /* We must check whether the decl refers to template
434 arguments before push_template_decl_real adds a
435 reference to the containing template class. */
436 int warn
= (warn_nontemplate_friend
437 && ! funcdef_flag
&& ! is_friend_template
438 && current_template_parms
439 && uses_template_parms (decl
));
441 if (is_friend_template
442 || template_class_depth (current_class_type
) != 0)
443 /* We can't call pushdecl for a template class, since in
444 general, such a declaration depends on template
445 parameters. Instead, we call pushdecl when the class
447 decl
= push_template_decl_real (decl
, /*is_friend=*/1);
448 else if (current_function_decl
)
449 /* This must be a local class, so pushdecl will be ok, and
450 insert an unqualified friend into the local scope
451 (rather than the containing namespace scope, which the
452 next choice will do). */
453 decl
= pushdecl (decl
);
456 /* We can't use pushdecl, as we might be in a template
457 class specialization, and pushdecl will insert an
458 unqualified friend decl into the template parameter
459 scope, rather than the namespace containing it. */
460 tree ns
= decl_namespace_context (decl
);
462 push_nested_namespace (ns
);
463 decl
= pushdecl_namespace_level (decl
);
464 pop_nested_namespace (ns
);
469 static int explained
;
470 warning ("friend declaration `%#D' declares a non-template function", decl
);
473 warning ("(if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning");
479 if (decl
== error_mark_node
)
480 return error_mark_node
;
482 add_friend (current_class_type
,
483 is_friend_template
? DECL_TI_TEMPLATE (decl
) : decl
,
485 DECL_FRIEND_P (decl
) = 1;
488 /* Unfortunately, we have to handle attributes here. Normally we would
489 handle them in start_decl_1, but since this is a friend decl start_decl_1
490 never gets to see it. */
492 /* Set attributes here so if duplicate decl, will have proper attributes. */
493 cplus_decl_attributes (&decl
, attrlist
, 0);