1 /* Help friends in C++.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
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 if (TREE_VALUE (friends
) == NULL_TREE
)
66 if (supplicant
== TREE_VALUE (friends
))
69 /* Temporarily, we are more lenient to deal with
70 nested friend functions, for which there can be
71 more than one FUNCTION_DECL, despite being the
72 same function. When that's fixed, this bit can
74 if (DECL_FUNCTION_MEMBER_P (supplicant
)
75 && same_type_p (TREE_TYPE (supplicant
),
76 TREE_TYPE (TREE_VALUE (friends
))))
79 if (TREE_CODE (TREE_VALUE (friends
)) == TEMPLATE_DECL
80 && is_specialization_of (supplicant
,
81 TREE_VALUE (friends
)))
91 /* Nested classes are implicitly friends of their enclosing types, as
92 per core issue 45 (this is a change from the standard). */
93 for (context
= supplicant
;
94 context
&& TYPE_P (context
);
95 context
= TYPE_CONTEXT (context
))
99 list
= CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type
)));
100 for (; list
; list
= TREE_CHAIN (list
))
102 tree t
= TREE_VALUE (list
);
104 if (TREE_CODE (t
) == TEMPLATE_DECL
?
105 is_specialization_of (TYPE_MAIN_DECL (supplicant
), t
) :
106 same_type_p (supplicant
, t
))
111 if (declp
&& DECL_FUNCTION_MEMBER_P (supplicant
))
112 context
= DECL_CONTEXT (supplicant
);
114 /* Local classes have the same access as the enclosing function. */
115 context
= decl_function_context (TYPE_MAIN_DECL (supplicant
));
119 /* A namespace is not friend to anybody. */
120 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
124 return is_friend (type
, context
);
129 /* Add a new friend to the friends of the aggregate type TYPE.
130 DECL is the FUNCTION_DECL of the friend being added. */
133 add_friend (tree type
, tree decl
)
139 if (decl
== error_mark_node
)
142 typedecl
= TYPE_MAIN_DECL (type
);
143 list
= DECL_FRIENDLIST (typedecl
);
144 name
= DECL_NAME (decl
);
145 type
= TREE_TYPE (typedecl
);
149 if (name
== FRIEND_NAME (list
))
151 tree friends
= FRIEND_DECLS (list
);
152 for (; friends
; friends
= TREE_CHAIN (friends
))
154 if (decl
== TREE_VALUE (friends
))
156 warning ("`%D' is already a friend of class `%T'",
158 cp_warning_at ("previous friend declaration of `%D'",
159 TREE_VALUE (friends
));
164 maybe_add_class_template_decl_list (type
, decl
, /*friend_p=*/1);
166 TREE_VALUE (list
) = tree_cons (NULL_TREE
, decl
,
170 list
= TREE_CHAIN (list
);
173 if (DECL_CLASS_SCOPE_P (decl
))
174 perform_or_defer_access_check (TYPE_BINFO (DECL_CONTEXT (decl
)), decl
);
176 maybe_add_class_template_decl_list (type
, decl
, /*friend_p=*/1);
178 DECL_FRIENDLIST (typedecl
)
179 = tree_cons (DECL_NAME (decl
), build_tree_list (NULL_TREE
, decl
),
180 DECL_FRIENDLIST (typedecl
));
181 if (!uses_template_parms (type
))
182 DECL_BEFRIENDING_CLASSES (decl
)
183 = tree_cons (NULL_TREE
, type
,
184 DECL_BEFRIENDING_CLASSES (decl
));
187 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already
188 been defined, we make all of its member functions friends of
189 TYPE. If not, we make it a pending friend, which can later be added
190 when its definition is seen. If a type is defined, then its TYPE_DECL's
191 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
192 classes that are not defined. If a type has not yet been defined,
193 then the DECL_WAITING_FRIENDS contains a list of types
194 waiting to make it their friend. Note that these two can both
195 be in use at the same time! */
198 make_friend_class (tree type
, tree friend_type
)
201 int is_template_friend
;
203 if (! IS_AGGR_TYPE (friend_type
))
205 error ("invalid type `%T' declared `friend'", friend_type
);
209 if (processing_template_decl
> template_class_depth (type
))
210 /* If the TYPE is a template then it makes sense for it to be
211 friends with itself; this means that each instantiation is
212 friends with all other instantiations. */
214 if (CLASS_TYPE_P (friend_type
)
215 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type
)
216 && uses_template_parms (friend_type
))
219 Friend declarations shall not declare partial
221 error ("partial specialization `%T' declared `friend'",
226 is_template_friend
= 1;
228 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
)
278 warning ("`%D' is already a friend of `%T'",
283 else if (TREE_CODE (probe
) != TEMPLATE_DECL
)
285 if (same_type_p (probe
, friend_type
))
287 warning ("`%T' is already a friend of `%T'",
296 maybe_add_class_template_decl_list (type
, friend_type
, /*friend_p=*/1);
298 CLASSTYPE_FRIEND_CLASSES (type
)
299 = tree_cons (NULL_TREE
, friend_type
, CLASSTYPE_FRIEND_CLASSES (type
));
300 if (is_template_friend
)
301 friend_type
= TREE_TYPE (friend_type
);
302 if (!uses_template_parms (type
))
303 CLASSTYPE_BEFRIENDING_CLASSES (friend_type
)
304 = tree_cons (NULL_TREE
, type
,
305 CLASSTYPE_BEFRIENDING_CLASSES (friend_type
));
309 /* Main friend processor.
311 CTYPE is the class this friend belongs to.
313 DECLARATOR is the name of the friend.
315 DECL is the FUNCTION_DECL that the friend is.
317 In case we are parsing a friend which is part of an inline
318 definition, we will need to store PARM_DECL chain that comes
319 with it into the DECL_ARGUMENTS slot of the FUNCTION_DECL.
321 FLAGS is just used for `grokclassfn'.
323 QUALS say what special qualifies should apply to the object
324 pointed to by `this'. */
327 do_friend (tree ctype
, tree declarator
, tree decl
, tree parmdecls
,
328 tree attrlist
, enum overload_flags flags
, tree quals
,
331 int is_friend_template
= 0;
333 /* Every decl that gets here is a friend of something. */
334 DECL_FRIEND_P (decl
) = 1;
336 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
338 declarator
= TREE_OPERAND (declarator
, 0);
339 if (is_overloaded_fn (declarator
))
340 declarator
= DECL_NAME (get_first_fn (declarator
));
343 if (TREE_CODE (decl
) != FUNCTION_DECL
)
346 is_friend_template
= PROCESSING_REAL_TEMPLATE_DECL_P ();
350 tree cname
= TYPE_NAME (ctype
);
351 if (TREE_CODE (cname
) == TYPE_DECL
)
352 cname
= DECL_NAME (cname
);
354 /* A method friend. */
355 if (flags
== NO_SPECIAL
&& ctype
&& declarator
== cname
)
356 DECL_CONSTRUCTOR_P (decl
) = 1;
358 /* This will set up DECL_ARGUMENTS for us. */
359 grokclassfn (ctype
, decl
, flags
, quals
);
361 if (is_friend_template
)
362 decl
= DECL_TI_TEMPLATE (push_template_decl (decl
));
363 else if (DECL_TEMPLATE_INFO (decl
))
365 else if (template_class_depth (current_class_type
))
366 decl
= push_template_decl_real (decl
, /*is_friend=*/1);
368 /* We can't do lookup in a type that involves template
369 parameters. Instead, we rely on tsubst_friend_function
370 to check the validity of the declaration later. */
371 if (processing_template_decl
)
372 add_friend (current_class_type
, decl
);
373 /* A nested class may declare a member of an enclosing class
374 to be a friend, so we do lookup here even if CTYPE is in
375 the process of being defined. */
376 else if (COMPLETE_TYPE_P (ctype
) || TYPE_BEING_DEFINED (ctype
))
378 decl
= check_classfn (ctype
, decl
);
381 add_friend (current_class_type
, decl
);
384 error ("member `%D' declared as friend before type `%T' defined",
388 @@ or possibly a friend from a base class ?!? */
389 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
391 /* Friends must all go through the overload machinery,
392 even though they may not technically be overloaded.
394 Note that because classes all wind up being top-level
395 in their scope, their friend wind up in top-level scope as well. */
396 DECL_ARGUMENTS (decl
) = parmdecls
;
398 SET_DECL_FRIEND_CONTEXT (decl
, current_class_type
);
400 if (! DECL_USE_TEMPLATE (decl
))
402 /* We must check whether the decl refers to template
403 arguments before push_template_decl_real adds a
404 reference to the containing template class. */
405 int warn
= (warn_nontemplate_friend
406 && ! funcdef_flag
&& ! is_friend_template
407 && current_template_parms
408 && uses_template_parms (decl
));
410 if (is_friend_template
411 || template_class_depth (current_class_type
) != 0)
412 /* We can't call pushdecl for a template class, since in
413 general, such a declaration depends on template
414 parameters. Instead, we call pushdecl when the class
416 decl
= push_template_decl_real (decl
, /*is_friend=*/1);
417 else if (current_function_decl
)
418 /* This must be a local class, so pushdecl will be ok, and
419 insert an unqualified friend into the local scope
420 (rather than the containing namespace scope, which the
421 next choice will do). */
422 decl
= pushdecl (decl
);
425 /* We can't use pushdecl, as we might be in a template
426 class specialization, and pushdecl will insert an
427 unqualified friend decl into the template parameter
428 scope, rather than the namespace containing it. */
429 tree ns
= decl_namespace_context (decl
);
431 push_nested_namespace (ns
);
432 decl
= pushdecl_namespace_level (decl
);
433 pop_nested_namespace (ns
);
438 static int explained
;
439 warning ("friend declaration `%#D' declares a non-template function", decl
);
442 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");
448 add_friend (current_class_type
,
449 is_friend_template
? DECL_TI_TEMPLATE (decl
) : decl
);
450 DECL_FRIEND_P (decl
) = 1;
453 /* Unfortunately, we have to handle attributes here. Normally we would
454 handle them in start_decl_1, but since this is a friend decl start_decl_1
455 never gets to see it. */
457 /* Set attributes here so if duplicate decl, will have proper attributes. */
458 cplus_decl_attributes (&decl
, attrlist
, 0);