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.
132 If COMPLAIN is true, warning about duplicate friend is issued.
133 We want to have this diagnostics during parsing but not
134 when a template is being instantiated. */
137 add_friend (tree type, tree decl, bool complain)
143 if (decl == error_mark_node)
146 typedecl = TYPE_MAIN_DECL (type);
147 list = DECL_FRIENDLIST (typedecl);
148 name = DECL_NAME (decl);
149 type = TREE_TYPE (typedecl);
153 if (name == FRIEND_NAME (list))
155 tree friends = FRIEND_DECLS (list);
156 for (; friends ; friends = TREE_CHAIN (friends))
158 if (decl == TREE_VALUE (friends))
162 warning ("`%D' is already a friend of class `%T'",
164 cp_warning_at ("previous friend declaration of `%D'",
165 TREE_VALUE (friends));
171 maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
173 TREE_VALUE (list) = tree_cons (NULL_TREE, decl,
177 list = TREE_CHAIN (list);
180 if (DECL_CLASS_SCOPE_P (decl))
181 perform_or_defer_access_check (TYPE_BINFO (DECL_CONTEXT (decl)), decl);
183 maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
185 DECL_FRIENDLIST (typedecl)
186 = tree_cons (DECL_NAME (decl), build_tree_list (NULL_TREE, decl),
187 DECL_FRIENDLIST (typedecl));
188 if (!uses_template_parms (type))
189 DECL_BEFRIENDING_CLASSES (decl)
190 = tree_cons (NULL_TREE, type,
191 DECL_BEFRIENDING_CLASSES (decl));
194 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already
195 been defined, we make all of its member functions friends of
196 TYPE. If not, we make it a pending friend, which can later be added
197 when its definition is seen. If a type is defined, then its TYPE_DECL's
198 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
199 classes that are not defined. If a type has not yet been defined,
200 then the DECL_WAITING_FRIENDS contains a list of types
201 waiting to make it their friend. Note that these two can both
202 be in use at the same time!
204 If COMPLAIN is true, warning about duplicate friend is issued.
205 We want to have this diagnostics during parsing but not
206 when a template is being instantiated. */
209 make_friend_class (tree type, tree friend_type, bool complain)
212 int is_template_friend;
214 if (! IS_AGGR_TYPE (friend_type))
216 error ("invalid type `%T' declared `friend'", friend_type);
220 if (processing_template_decl > template_class_depth (type))
221 /* If the TYPE is a template then it makes sense for it to be
222 friends with itself; this means that each instantiation is
223 friends with all other instantiations. */
225 if (CLASS_TYPE_P (friend_type)
226 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type)
227 && uses_template_parms (friend_type))
230 Friend declarations shall not declare partial
232 error ("partial specialization `%T' declared `friend'",
237 is_template_friend = 1;
239 else if (same_type_p (type, friend_type))
242 pedwarn ("class `%T' is implicitly friends with itself",
247 is_template_friend = 0;
251 A friend of a class or class template can be a function or
252 class template, a specialization of a function template or
253 class template, or an ordinary (nontemplate) function or
255 if (!is_template_friend)
257 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
259 /* template <class T> friend typename S<T>::X; */
260 error ("typename type `%#T' declared `friend'", friend_type);
263 else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
265 /* template <class T> friend class T; */
266 error ("template parameter type `%T' declared `friend'", friend_type);
269 else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
271 /* template <class T> friend class A; where A is not a template */
272 error ("`%#T' is not a template", friend_type);
276 if (is_template_friend)
277 friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
279 /* See if it is already a friend. */
280 for (classes = CLASSTYPE_FRIEND_CLASSES (type);
282 classes = TREE_CHAIN (classes))
284 tree probe = TREE_VALUE (classes);
286 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
288 if (friend_type == probe)
291 warning ("`%D' is already a friend of `%T'",
296 else if (TREE_CODE (probe) != TEMPLATE_DECL)
298 if (same_type_p (probe, friend_type))
301 warning ("`%T' is already a friend of `%T'",
310 maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1);
312 CLASSTYPE_FRIEND_CLASSES (type)
313 = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
314 if (is_template_friend)
315 friend_type = TREE_TYPE (friend_type);
316 if (!uses_template_parms (type))
317 CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
318 = tree_cons (NULL_TREE, type,
319 CLASSTYPE_BEFRIENDING_CLASSES (friend_type));
323 /* Main friend processor.
325 CTYPE is the class this friend belongs to.
327 DECLARATOR is the name of the friend.
329 DECL is the FUNCTION_DECL that the friend is.
331 In case we are parsing a friend which is part of an inline
332 definition, we will need to store PARM_DECL chain that comes
333 with it into the DECL_ARGUMENTS slot of the FUNCTION_DECL.
335 FLAGS is just used for `grokclassfn'.
337 QUALS say what special qualifies should apply to the object
338 pointed to by `this'. */
341 do_friend (tree ctype, tree declarator, tree decl, tree parmdecls,
342 tree attrlist, enum overload_flags flags, tree quals,
345 int is_friend_template = 0;
347 /* Every decl that gets here is a friend of something. */
348 DECL_FRIEND_P (decl) = 1;
350 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
352 declarator = TREE_OPERAND (declarator, 0);
353 if (is_overloaded_fn (declarator))
354 declarator = DECL_NAME (get_first_fn (declarator));
357 if (TREE_CODE (decl) != FUNCTION_DECL)
360 is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P ();
364 tree cname = TYPE_NAME (ctype);
365 if (TREE_CODE (cname) == TYPE_DECL)
366 cname = DECL_NAME (cname);
368 /* A method friend. */
369 if (flags == NO_SPECIAL && ctype && declarator == cname)
370 DECL_CONSTRUCTOR_P (decl) = 1;
372 /* This will set up DECL_ARGUMENTS for us. */
373 grokclassfn (ctype, decl, flags, quals);
375 if (is_friend_template)
376 decl = DECL_TI_TEMPLATE (push_template_decl (decl));
377 else if (DECL_TEMPLATE_INFO (decl))
379 else if (template_class_depth (current_class_type))
380 decl = push_template_decl_real (decl, /*is_friend=*/1);
382 /* We can't do lookup in a type that involves template
383 parameters. Instead, we rely on tsubst_friend_function
384 to check the validity of the declaration later. */
385 if (processing_template_decl)
386 add_friend (current_class_type, decl, /*complain=*/true);
387 /* A nested class may declare a member of an enclosing class
388 to be a friend, so we do lookup here even if CTYPE is in
389 the process of being defined. */
390 else if (COMPLETE_TYPE_P (ctype) || TYPE_BEING_DEFINED (ctype))
392 decl = check_classfn (ctype, decl);
395 add_friend (current_class_type, decl, /*complain=*/true);
398 error ("member `%D' declared as friend before type `%T' defined",
402 @@ or possibly a friend from a base class ?!? */
403 else if (TREE_CODE (decl) == FUNCTION_DECL)
405 /* Friends must all go through the overload machinery,
406 even though they may not technically be overloaded.
408 Note that because classes all wind up being top-level
409 in their scope, their friend wind up in top-level scope as well. */
410 DECL_ARGUMENTS (decl) = parmdecls;
412 SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
414 if (! DECL_USE_TEMPLATE (decl))
416 /* We must check whether the decl refers to template
417 arguments before push_template_decl_real adds a
418 reference to the containing template class. */
419 int warn = (warn_nontemplate_friend
420 && ! funcdef_flag && ! is_friend_template
421 && current_template_parms
422 && uses_template_parms (decl));
424 if (is_friend_template
425 || template_class_depth (current_class_type) != 0)
426 /* We can't call pushdecl for a template class, since in
427 general, such a declaration depends on template
428 parameters. Instead, we call pushdecl when the class
430 decl = push_template_decl_real (decl, /*is_friend=*/1);
431 else if (current_function_decl)
432 /* This must be a local class, so pushdecl will be ok, and
433 insert an unqualified friend into the local scope
434 (rather than the containing namespace scope, which the
435 next choice will do). */
436 decl = pushdecl (decl);
439 /* We can't use pushdecl, as we might be in a template
440 class specialization, and pushdecl will insert an
441 unqualified friend decl into the template parameter
442 scope, rather than the namespace containing it. */
443 tree ns = decl_namespace_context (decl);
445 push_nested_namespace (ns);
446 decl = pushdecl_namespace_level (decl);
447 pop_nested_namespace (ns);
452 static int explained;
453 warning ("friend declaration `%#D' declares a non-template function", decl);
456 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");
462 add_friend (current_class_type,
463 is_friend_template ? DECL_TI_TEMPLATE (decl) : decl,
465 DECL_FRIEND_P (decl) = 1;
468 /* Unfortunately, we have to handle attributes here. Normally we would
469 handle them in start_decl_1, but since this is a friend decl start_decl_1
470 never gets to see it. */
472 /* Set attributes here so if duplicate decl, will have proper attributes. */
473 cplus_decl_attributes (&decl, attrlist, 0);