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 maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
175 DECL_FRIENDLIST (typedecl)
176 = tree_cons (DECL_NAME (decl), build_tree_list (NULL_TREE, decl),
177 DECL_FRIENDLIST (typedecl));
178 if (!uses_template_parms (type))
179 DECL_BEFRIENDING_CLASSES (decl)
180 = tree_cons (NULL_TREE, type,
181 DECL_BEFRIENDING_CLASSES (decl));
184 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already
185 been defined, we make all of its member functions friends of
186 TYPE. If not, we make it a pending friend, which can later be added
187 when its definition is seen. If a type is defined, then its TYPE_DECL's
188 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
189 classes that are not defined. If a type has not yet been defined,
190 then the DECL_WAITING_FRIENDS contains a list of types
191 waiting to make it their friend. Note that these two can both
192 be in use at the same time! */
195 make_friend_class (tree type, tree friend_type)
198 int is_template_friend;
200 if (! IS_AGGR_TYPE (friend_type))
202 error ("invalid type `%T' declared `friend'", friend_type);
206 if (processing_template_decl > template_class_depth (type))
207 /* If the TYPE is a template then it makes sense for it to be
208 friends with itself; this means that each instantiation is
209 friends with all other instantiations. */
211 if (CLASS_TYPE_P (friend_type)
212 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type)
213 && uses_template_parms (friend_type))
216 Friend declarations shall not declare partial
218 error ("partial specialization `%T' declared `friend'",
223 is_template_friend = 1;
225 else if (same_type_p (type, friend_type))
227 pedwarn ("class `%T' is implicitly friends with itself",
232 is_template_friend = 0;
236 A friend of a class or class template can be a function or
237 class template, a specialization of a function template or
238 class template, or an ordinary (nontemplate) function or
240 if (!is_template_friend)
242 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
244 /* template <class T> friend typename S<T>::X; */
245 error ("typename type `%#T' declared `friend'", friend_type);
248 else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
250 /* template <class T> friend class T; */
251 error ("template parameter type `%T' declared `friend'", friend_type);
254 else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
256 /* template <class T> friend class A; where A is not a template */
257 error ("`%#T' is not a template", friend_type);
261 if (is_template_friend)
262 friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
264 /* See if it is already a friend. */
265 for (classes = CLASSTYPE_FRIEND_CLASSES (type);
267 classes = TREE_CHAIN (classes))
269 tree probe = TREE_VALUE (classes);
271 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
273 if (friend_type == probe)
275 warning ("`%D' is already a friend of `%T'",
280 else if (TREE_CODE (probe) != TEMPLATE_DECL)
282 if (same_type_p (probe, friend_type))
284 warning ("`%T' is already a friend of `%T'",
293 maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1);
295 CLASSTYPE_FRIEND_CLASSES (type)
296 = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
297 if (is_template_friend)
298 friend_type = TREE_TYPE (friend_type);
299 if (!uses_template_parms (type))
300 CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
301 = tree_cons (NULL_TREE, type,
302 CLASSTYPE_BEFRIENDING_CLASSES (friend_type));
306 /* Main friend processor.
308 CTYPE is the class this friend belongs to.
310 DECLARATOR is the name of the friend.
312 DECL is the FUNCTION_DECL that the friend is.
314 In case we are parsing a friend which is part of an inline
315 definition, we will need to store PARM_DECL chain that comes
316 with it into the DECL_ARGUMENTS slot of the FUNCTION_DECL.
318 FLAGS is just used for `grokclassfn'.
320 QUALS say what special qualifies should apply to the object
321 pointed to by `this'. */
324 do_friend (tree ctype, tree declarator, tree decl, tree parmdecls,
325 tree attrlist, enum overload_flags flags, tree quals,
328 int is_friend_template = 0;
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 (TREE_CODE (declarator) == LOOKUP_EXPR)
337 declarator = TREE_OPERAND (declarator, 0);
338 if (is_overloaded_fn (declarator))
339 declarator = DECL_NAME (get_first_fn (declarator));
342 if (TREE_CODE (decl) != FUNCTION_DECL)
345 is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P ();
349 tree cname = TYPE_NAME (ctype);
350 if (TREE_CODE (cname) == TYPE_DECL)
351 cname = DECL_NAME (cname);
353 /* A method friend. */
354 if (flags == NO_SPECIAL && ctype && declarator == cname)
355 DECL_CONSTRUCTOR_P (decl) = 1;
357 /* This will set up DECL_ARGUMENTS for us. */
358 grokclassfn (ctype, decl, flags, quals);
360 if (is_friend_template)
361 decl = DECL_TI_TEMPLATE (push_template_decl (decl));
362 else if (template_class_depth (current_class_type))
363 decl = push_template_decl_real (decl, /*is_friend=*/1);
365 /* We can't do lookup in a type that involves template
366 parameters. Instead, we rely on tsubst_friend_function
367 to check the validity of the declaration later. */
368 if (processing_template_decl)
369 add_friend (current_class_type, decl);
370 /* A nested class may declare a member of an enclosing class
371 to be a friend, so we do lookup here even if CTYPE is in
372 the process of being defined. */
373 else if (COMPLETE_TYPE_P (ctype) || TYPE_BEING_DEFINED (ctype))
375 decl = check_classfn (ctype, decl);
378 add_friend (current_class_type, decl);
381 error ("member `%D' declared as friend before type `%T' defined",
385 @@ or possibly a friend from a base class ?!? */
386 else if (TREE_CODE (decl) == FUNCTION_DECL)
388 /* Friends must all go through the overload machinery,
389 even though they may not technically be overloaded.
391 Note that because classes all wind up being top-level
392 in their scope, their friend wind up in top-level scope as well. */
393 DECL_ARGUMENTS (decl) = parmdecls;
395 SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
397 if (! DECL_USE_TEMPLATE (decl))
399 /* We must check whether the decl refers to template
400 arguments before push_template_decl_real adds a
401 reference to the containing template class. */
402 int warn = (warn_nontemplate_friend
403 && ! funcdef_flag && ! is_friend_template
404 && current_template_parms
405 && uses_template_parms (decl));
407 if (is_friend_template
408 || template_class_depth (current_class_type) != 0)
409 /* We can't call pushdecl for a template class, since in
410 general, such a declaration depends on template
411 parameters. Instead, we call pushdecl when the class
413 decl = push_template_decl_real (decl, /*is_friend=*/1);
414 else if (current_function_decl)
415 /* This must be a local class, so pushdecl will be ok, and
416 insert an unqualified friend into the local scope
417 (rather than the containing namespace scope, which the
418 next choice will do). */
419 decl = pushdecl (decl);
422 /* We can't use pushdecl, as we might be in a template
423 class specialization, and pushdecl will insert an
424 unqualified friend decl into the template parameter
425 scope, rather than the namespace containing it. */
426 tree ns = decl_namespace_context (decl);
428 push_nested_namespace (ns);
429 decl = pushdecl_namespace_level (decl);
430 pop_nested_namespace (ns);
435 static int explained;
436 warning ("friend declaration `%#D' declares a non-template function", decl);
439 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");
445 add_friend (current_class_type,
446 is_friend_template ? DECL_TI_TEMPLATE (decl) : decl);
447 DECL_FRIEND_P (decl) = 1;
450 /* Unfortunately, we have to handle attributes here. Normally we would
451 handle them in start_decl_1, but since this is a friend decl start_decl_1
452 never gets to see it. */
454 /* Set attributes here so if duplicate decl, will have proper attributes. */
455 cplus_decl_attributes (&decl, attrlist, 0);