Branch data Line data Source code
1 : : /* Help friends in C++.
2 : : Copyright (C) 1997-2024 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
6 : : GCC is free software; you can redistribute it and/or modify
7 : : it under the terms of the GNU General Public License as published by
8 : : the Free Software Foundation; either version 3, or (at your option)
9 : : any later version.
10 : :
11 : : GCC is distributed in the hope that it will be useful,
12 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : GNU General Public License for more details.
15 : :
16 : : You should have received a copy of the GNU General Public License
17 : : along with GCC; see the file COPYING3. If not see
18 : : <http://www.gnu.org/licenses/>. */
19 : :
20 : : #include "config.h"
21 : : #include "system.h"
22 : : #include "coretypes.h"
23 : : #include "cp-tree.h"
24 : :
25 : : /* Friend data structures are described in cp-tree.h. */
26 : :
27 : :
28 : : /* The GLOBAL_FRIEND scope (functions, classes, or templates) is
29 : : regarded as a friend of every class. This is only used by libcc1,
30 : : to enable GDB's code snippets to access private members without
31 : : disabling access control in general, which could cause different
32 : : template overload resolution results when accessibility matters
33 : : (e.g. tests for an accessible member). */
34 : :
35 : : static GTY(()) tree global_friend;
36 : :
37 : : /* Set the GLOBAL_FRIEND for this compilation session. It might be
38 : : set multiple times, but always to the same scope. */
39 : :
40 : : void
41 : 0 : set_global_friend (tree scope)
42 : : {
43 : 0 : gcc_checking_assert (scope != NULL_TREE);
44 : 0 : gcc_assert (!global_friend || global_friend == scope);
45 : 0 : global_friend = scope;
46 : 0 : }
47 : :
48 : : /* Return TRUE if SCOPE is the global friend. */
49 : :
50 : : bool
51 : 71394847 : is_global_friend (tree scope)
52 : : {
53 : 71394847 : gcc_checking_assert (scope != NULL_TREE);
54 : :
55 : 71394847 : if (global_friend == scope)
56 : : return true;
57 : :
58 : 71394847 : if (!global_friend)
59 : : return false;
60 : :
61 : 0 : if (is_specialization_of_friend (global_friend, scope))
62 : : return true;
63 : :
64 : : return false;
65 : : }
66 : :
67 : : /* Returns nonzero if SUPPLICANT is a friend of TYPE. */
68 : :
69 : : int
70 : 30076313 : is_friend (tree type, tree supplicant)
71 : : {
72 : 57180908 : int declp;
73 : 57180908 : tree list;
74 : 57180908 : tree context;
75 : :
76 : 57180908 : if (supplicant == NULL_TREE || type == NULL_TREE)
77 : : return 0;
78 : :
79 : 57180908 : if (is_global_friend (supplicant))
80 : : return 1;
81 : :
82 : 57180908 : declp = DECL_P (supplicant);
83 : :
84 : 57180908 : if (declp)
85 : : /* It's a function decl. */
86 : : {
87 : 27054631 : tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
88 : 27054631 : tree name = DECL_NAME (supplicant);
89 : :
90 : 56494697 : for (; list ; list = TREE_CHAIN (list))
91 : : {
92 : 30383584 : if (name == FRIEND_NAME (list))
93 : : {
94 : 943518 : tree friends = FRIEND_DECLS (list);
95 : 1322203 : for (; friends ; friends = TREE_CHAIN (friends))
96 : : {
97 : 1032298 : tree this_friend = TREE_VALUE (friends);
98 : :
99 : 1032298 : if (this_friend == NULL_TREE)
100 : 0 : continue;
101 : :
102 : 1032298 : if (supplicant == this_friend)
103 : : return 1;
104 : :
105 : 509446 : if (is_specialization_of_friend (supplicant, this_friend))
106 : : return 1;
107 : : }
108 : : break;
109 : : }
110 : : }
111 : : }
112 : : else
113 : : /* It's a type. */
114 : : {
115 : 30126277 : if (same_type_p (supplicant, type))
116 : : return 1;
117 : :
118 : 1495719 : list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type)));
119 : 1932403 : for (; list ; list = TREE_CHAIN (list))
120 : : {
121 : 1178667 : tree t = TREE_VALUE (list);
122 : :
123 : 2357334 : if (TREE_CODE (t) == TEMPLATE_DECL ?
124 : 705444 : is_specialization_of_friend (TYPE_MAIN_DECL (supplicant), t) :
125 : 473223 : same_type_p (supplicant, t))
126 : : return 1;
127 : : }
128 : : }
129 : :
130 : 27154754 : if (declp)
131 : : {
132 : 26401018 : if (DECL_FUNCTION_MEMBER_P (supplicant))
133 : 26399524 : context = DECL_CONTEXT (supplicant);
134 : 2988 : else if (tree fc = DECL_FRIEND_CONTEXT (supplicant))
135 : : context = fc;
136 : : else
137 : : context = NULL_TREE;
138 : : }
139 : : else
140 : : {
141 : 753736 : if (TYPE_CLASS_SCOPE_P (supplicant))
142 : : /* Nested classes get the same access as their enclosing types, as
143 : : per DR 45 (this is a change from the standard). */
144 : 535683 : context = TYPE_CONTEXT (supplicant);
145 : : else
146 : : /* Local classes have the same access as the enclosing function. */
147 : 218053 : context = decl_function_context (TYPE_MAIN_DECL (supplicant));
148 : : }
149 : :
150 : : /* A namespace is not friend to anybody. */
151 : 27153341 : if (context && TREE_CODE (context) == NAMESPACE_DECL)
152 : : context = NULL_TREE;
153 : :
154 : : if (context)
155 : : return is_friend (type, context);
156 : :
157 : : return 0;
158 : : }
159 : :
160 : : /* Add a new friend to the friends of the aggregate type TYPE.
161 : : DECL is the FUNCTION_DECL of the friend being added.
162 : :
163 : : If COMPLAIN is true, warning about duplicate friend is issued.
164 : : We want to have this diagnostics during parsing but not
165 : : when a template is being instantiated. */
166 : :
167 : : void
168 : 4998833 : add_friend (tree type, tree decl, bool complain)
169 : : {
170 : 4998833 : tree typedecl;
171 : 4998833 : tree list;
172 : 4998833 : tree name;
173 : 4998833 : tree ctx;
174 : :
175 : 4998833 : if (decl == error_mark_node)
176 : : return;
177 : :
178 : 4998796 : typedecl = TYPE_MAIN_DECL (type);
179 : 4998796 : list = DECL_FRIENDLIST (typedecl);
180 : 4998796 : name = DECL_NAME (decl);
181 : 4998796 : type = TREE_TYPE (typedecl);
182 : :
183 : 11015942 : while (list)
184 : : {
185 : 6736660 : if (name == FRIEND_NAME (list))
186 : : {
187 : 719514 : tree friends = FRIEND_DECLS (list);
188 : 2043053 : for (; friends ; friends = TREE_CHAIN (friends))
189 : : {
190 : 1323622 : if (decl == TREE_VALUE (friends))
191 : : {
192 : 83 : if (complain)
193 : 75 : warning (OPT_Wredundant_decls,
194 : : "%qD is already a friend of class %qT",
195 : : decl, type);
196 : 83 : return;
197 : : }
198 : : }
199 : :
200 : 719431 : TREE_VALUE (list) = tree_cons (NULL_TREE, decl,
201 : 719431 : TREE_VALUE (list));
202 : 719431 : break;
203 : : }
204 : 6017146 : list = TREE_CHAIN (list);
205 : : }
206 : :
207 : 4998713 : ctx = DECL_CONTEXT (decl);
208 : 4998713 : if (ctx && CLASS_TYPE_P (ctx) && !uses_template_parms (ctx))
209 : 133 : perform_or_defer_access_check (TYPE_BINFO (ctx), decl, decl,
210 : : tf_warning_or_error);
211 : :
212 : 4998713 : maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
213 : :
214 : 4998713 : if (!list)
215 : 4279282 : DECL_FRIENDLIST (typedecl)
216 : 8558564 : = tree_cons (DECL_NAME (decl), build_tree_list (NULL_TREE, decl),
217 : 4279282 : DECL_FRIENDLIST (typedecl));
218 : 4998713 : if (!uses_template_parms (type))
219 : 2794625 : DECL_BEFRIENDING_CLASSES (decl)
220 : 2794625 : = tree_cons (NULL_TREE, type,
221 : 2794625 : DECL_BEFRIENDING_CLASSES (decl));
222 : : }
223 : :
224 : : /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already
225 : : been defined, we make all of its member functions friends of
226 : : TYPE. If not, we make it a pending friend, which can later be added
227 : : when its definition is seen. If a type is defined, then its TYPE_DECL's
228 : : DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
229 : : classes that are not defined. If a type has not yet been defined,
230 : : then the DECL_WAITING_FRIENDS contains a list of types
231 : : waiting to make it their friend. Note that these two can both
232 : : be in use at the same time!
233 : :
234 : : If COMPLAIN is true, warning about duplicate friend is issued.
235 : : We want to have this diagnostics during parsing but not
236 : : when a template is being instantiated. */
237 : :
238 : : void
239 : 2359260 : make_friend_class (tree type, tree friend_type, bool complain)
240 : : {
241 : 2359260 : tree classes;
242 : :
243 : : /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
244 : : the enclosing class. FRIEND_DEPTH counts the number of template
245 : : headers used for this friend declaration. TEMPLATE_MEMBER_P,
246 : : defined inside the `if' block for TYPENAME_TYPE case, is true if
247 : : a template header in FRIEND_DEPTH is intended for DECLARATOR.
248 : : For example, the code
249 : :
250 : : template <class T> struct A {
251 : : template <class U> struct B {
252 : : template <class V> template <class W>
253 : : friend class C<V>::D;
254 : : };
255 : : };
256 : :
257 : : will eventually give the following results
258 : :
259 : : 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
260 : : 2. FRIEND_DEPTH equals 2 (for `V' and `W').
261 : : 3. TEMPLATE_MEMBER_P is true (for `W').
262 : :
263 : : The friend is a template friend iff FRIEND_DEPTH is nonzero. */
264 : :
265 : 2359260 : int class_template_depth = template_class_depth (type);
266 : 2359260 : int friend_depth = 0;
267 : 2359260 : if (current_template_depth)
268 : : /* When processing a friend declaration at parse time, just compare the
269 : : current depth to that of the class template. */
270 : 1082940 : friend_depth = current_template_depth - class_template_depth;
271 : : else
272 : : {
273 : : /* Otherwise, we got here from instantiate_class_template. Determine
274 : : the friend depth by looking at the template parameters used within
275 : : FRIEND_TYPE. */
276 : 1276320 : gcc_checking_assert (class_template_depth == 0);
277 : 1842480 : while (uses_template_parms_level (friend_type, friend_depth + 1))
278 : : ++friend_depth;
279 : : }
280 : :
281 : 2359260 : if (! MAYBE_CLASS_TYPE_P (friend_type)
282 : 21 : && TREE_CODE (friend_type) != TEMPLATE_TEMPLATE_PARM)
283 : : {
284 : : /* N1791: If the type specifier in a friend declaration designates a
285 : : (possibly cv-qualified) class type, that class is declared as a
286 : : friend; otherwise, the friend declaration is ignored.
287 : :
288 : : So don't complain in C++11 mode. */
289 : 18 : if (cxx_dialect < cxx11)
290 : 0 : pedwarn (input_location, complain ? 0 : OPT_Wpedantic,
291 : : "invalid type %qT declared %<friend%>", friend_type);
292 : 18 : return;
293 : : }
294 : :
295 : 2359242 : friend_type = cv_unqualified (friend_type);
296 : :
297 : 2359242 : if (check_for_bare_parameter_packs (friend_type))
298 : : return;
299 : :
300 : 2359239 : if (friend_depth)
301 : : {
302 : : /* [temp.friend] Friend declarations shall not declare partial
303 : : specializations. */
304 : 1098841 : if (CLASS_TYPE_P (friend_type)
305 : 1098841 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type)
306 : 1098930 : && uses_template_parms (friend_type))
307 : : {
308 : 0 : error ("partial specialization %qT declared %<friend%>",
309 : : friend_type);
310 : 0 : return;
311 : : }
312 : :
313 : 1098926 : if (TYPE_TEMPLATE_INFO (friend_type)
314 : 1098841 : && !PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (friend_type)))
315 : : {
316 : 4 : auto_diagnostic_group d;
317 : 4 : error ("%qT is not a template", friend_type);
318 : 4 : inform (location_of (friend_type), "previous declaration here");
319 : 8 : if (TYPE_CLASS_SCOPE_P (friend_type)
320 : 4 : && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (friend_type))
321 : 8 : && currently_open_class (TYPE_CONTEXT (friend_type)))
322 : 4 : inform (input_location, "perhaps you need explicit template "
323 : : "arguments in your nested-name-specifier");
324 : 4 : return;
325 : 4 : }
326 : : }
327 : :
328 : : /* It makes sense for a template class to be friends with itself,
329 : : that means the instantiations can be friendly. Other cases are
330 : : not so meaningful. */
331 : 1260313 : if (!friend_depth && same_type_p (type, friend_type))
332 : : {
333 : 8 : if (complain)
334 : 0 : warning (0, "class %qT is implicitly friends with itself",
335 : : type);
336 : 8 : return;
337 : : }
338 : :
339 : : /* [temp.friend]
340 : :
341 : : A friend of a class or class template can be a function or
342 : : class template, a specialization of a function template or
343 : : class template, or an ordinary (nontemplate) function or
344 : : class. */
345 : 2359227 : if (!friend_depth)
346 : : ;/* ok */
347 : 1098922 : else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
348 : : {
349 : 82 : if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type))
350 : : == TEMPLATE_ID_EXPR)
351 : : {
352 : : /* template <class U> friend class T::X<U>; */
353 : : /* [temp.friend]
354 : : Friend declarations shall not declare partial
355 : : specializations. */
356 : 0 : error ("partial specialization %qT declared %<friend%>",
357 : : friend_type);
358 : 0 : return;
359 : : }
360 : : else
361 : : {
362 : : /* We will figure this out later. */
363 : 82 : bool template_member_p = false;
364 : :
365 : 82 : tree ctype = TYPE_CONTEXT (friend_type);
366 : 82 : tree name = TYPE_IDENTIFIER (friend_type);
367 : 82 : tree decl;
368 : :
369 : : /* We need to distinguish a TYPENAME_TYPE for the non-template
370 : : class B in
371 : : template<class T> friend class A<T>::B;
372 : : vs for the class template B in
373 : : template<class T> template<class U> friend class A<T>::B; */
374 : 82 : if (current_template_depth
375 : 66 : && !uses_template_parms_level (ctype, current_template_depth))
376 : : template_member_p = true;
377 : :
378 : 82 : if (class_template_depth)
379 : : {
380 : : /* We rely on tsubst_friend_class to check the
381 : : validity of the declaration later. */
382 : 28 : if (template_member_p)
383 : 12 : friend_type
384 : 12 : = make_unbound_class_template (ctype,
385 : : name,
386 : : current_template_parms,
387 : : tf_error);
388 : : else
389 : 16 : friend_type
390 : 16 : = make_typename_type (ctype, name, class_type, tf_error);
391 : : }
392 : : else
393 : : {
394 : 54 : decl = lookup_member (ctype, name, 0, true, tf_warning_or_error);
395 : 54 : if (!decl)
396 : : {
397 : 0 : error ("%qT is not a member of %qT", name, ctype);
398 : 0 : return;
399 : : }
400 : 54 : if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl))
401 : : {
402 : 0 : auto_diagnostic_group d;
403 : 0 : error ("%qT is not a member class template of %qT",
404 : : name, ctype);
405 : 0 : inform (DECL_SOURCE_LOCATION (decl),
406 : : "%qD declared here", decl);
407 : 0 : return;
408 : 0 : }
409 : 54 : if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL
410 : 42 : || !CLASS_TYPE_P (TREE_TYPE (decl))))
411 : : {
412 : 0 : auto_diagnostic_group d;
413 : 0 : error ("%qT is not a nested class of %qT",
414 : : name, ctype);
415 : 0 : inform (DECL_SOURCE_LOCATION (decl),
416 : : "%qD declared here", decl);
417 : 0 : return;
418 : 0 : }
419 : :
420 : 54 : friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl));
421 : : }
422 : : }
423 : : }
424 : 1098840 : else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
425 : : {
426 : : /* template <class T> friend class T; */
427 : 0 : error ("template parameter type %qT declared %<friend%>", friend_type);
428 : 0 : return;
429 : : }
430 : 1098840 : else if (TREE_CODE (friend_type) == TEMPLATE_TEMPLATE_PARM)
431 : 3 : friend_type = TYPE_NAME (friend_type);
432 : 1098837 : else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
433 : : {
434 : : /* template <class T> friend class A; where A is not a template */
435 : 0 : error ("%q#T is not a template", friend_type);
436 : 0 : return;
437 : : }
438 : : else
439 : : /* template <class T> friend class A; where A is a template */
440 : 1098837 : friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
441 : :
442 : 2359227 : if (friend_type == error_mark_node)
443 : : return;
444 : :
445 : : /* See if it is already a friend. */
446 : 2359227 : for (classes = CLASSTYPE_FRIEND_CLASSES (type);
447 : 3709716 : classes;
448 : 1350489 : classes = TREE_CHAIN (classes))
449 : : {
450 : 1351537 : tree probe = TREE_VALUE (classes);
451 : :
452 : 1351537 : if (TREE_CODE (friend_type) == TEMPLATE_DECL)
453 : : {
454 : 677888 : if (friend_type == probe)
455 : : {
456 : 2 : if (complain)
457 : 0 : warning (OPT_Wredundant_decls,
458 : : "%qD is already a friend of %qT", probe, type);
459 : : break;
460 : : }
461 : : }
462 : 673649 : else if (TREE_CODE (probe) != TEMPLATE_DECL)
463 : : {
464 : 533876 : if (same_type_p (probe, friend_type))
465 : : {
466 : 1046 : if (complain)
467 : 1042 : warning (OPT_Wredundant_decls,
468 : : "%qT is already a friend of %qT", probe, type);
469 : : break;
470 : : }
471 : : }
472 : : }
473 : :
474 : 2359227 : if (!classes)
475 : : {
476 : 2358179 : maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1);
477 : :
478 : 2358179 : CLASSTYPE_FRIEND_CLASSES (type)
479 : 2358179 : = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
480 : 2358179 : if (TREE_CODE (friend_type) == TEMPLATE_DECL)
481 : 1098892 : friend_type = TREE_TYPE (friend_type);
482 : 2358179 : if (!uses_template_parms (type))
483 : 1338422 : CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
484 : 1338422 : = tree_cons (NULL_TREE, type,
485 : 1338422 : CLASSTYPE_BEFRIENDING_CLASSES (friend_type));
486 : : }
487 : : }
488 : :
489 : : /* Record DECL (a FUNCTION_DECL) as a friend of the
490 : : CURRENT_CLASS_TYPE. If DECL is a member function, SCOPE is the
491 : : class of which it is a member, as named in the friend declaration.
492 : : If the friend declaration was explicitly namespace-qualified, SCOPE
493 : : is that namespace.
494 : : DECLARATOR is the name of the friend. FUNCDEF_FLAG is true if the
495 : : friend declaration is a definition of the function. FLAGS is as
496 : : for grokclass fn. */
497 : :
498 : : tree
499 : 3374459 : do_friend (tree scope, tree declarator, tree decl,
500 : : enum overload_flags flags,
501 : : bool funcdef_flag)
502 : : {
503 : 3374459 : gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
504 : :
505 : 3374459 : tree ctype = NULL_TREE;
506 : 3374459 : tree in_namespace = NULL_TREE;
507 : 3374459 : if (!scope)
508 : : ;
509 : 85720 : else if (MAYBE_CLASS_TYPE_P (scope))
510 : : ctype = scope;
511 : : else
512 : : {
513 : 85441 : gcc_checking_assert (TREE_CODE (scope) == NAMESPACE_DECL);
514 : : in_namespace = scope;
515 : : }
516 : :
517 : : /* Friend functions are unique, until proved otherwise. */
518 : 3374459 : DECL_UNIQUE_FRIEND_P (decl) = 1;
519 : :
520 : 6748915 : if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl))
521 : 6 : error ("friend declaration %qD may not have virt-specifiers",
522 : : decl);
523 : :
524 : 3374459 : tree orig_declarator = declarator;
525 : 3374459 : if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
526 : : {
527 : 11117 : declarator = TREE_OPERAND (declarator, 0);
528 : 22231 : if (!identifier_p (declarator))
529 : 11111 : declarator = OVL_NAME (declarator);
530 : : }
531 : :
532 : : /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
533 : : the enclosing class. FRIEND_DEPTH counts the number of template
534 : : headers used for this friend declaration. TEMPLATE_MEMBER_P is
535 : : true if a template header in FRIEND_DEPTH is intended for
536 : : DECLARATOR. For example, the code
537 : :
538 : : template <class T> struct A {
539 : : template <class U> struct B {
540 : : template <class V> template <class W>
541 : : friend void C<V>::f(W);
542 : : };
543 : : };
544 : :
545 : : will eventually give the following results
546 : :
547 : : 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
548 : : 2. FRIEND_DEPTH equals 2 (for `V' and `W').
549 : : 3. CTYPE_DEPTH equals 1 (for `V').
550 : : 4. TEMPLATE_MEMBER_P is true (for `W'). */
551 : :
552 : 3374459 : int class_template_depth = template_class_depth (current_class_type);
553 : 3374459 : int friend_depth = current_template_depth - class_template_depth;
554 : 3374459 : int ctype_depth = num_template_headers_for_class (ctype);
555 : 3374459 : bool template_member_p = friend_depth > ctype_depth;
556 : :
557 : 3374459 : if (ctype)
558 : : {
559 : 279 : tree cname = TYPE_NAME (ctype);
560 : 279 : if (TREE_CODE (cname) == TYPE_DECL)
561 : 279 : cname = DECL_NAME (cname);
562 : :
563 : : /* A method friend. */
564 : 279 : if (flags == NO_SPECIAL && declarator == cname)
565 : 28 : DECL_CXX_CONSTRUCTOR_P (decl) = 1;
566 : :
567 : 279 : grokclassfn (ctype, decl, flags);
568 : :
569 : : /* A nested class may declare a member of an enclosing class
570 : : to be a friend, so we do lookup here even if CTYPE is in
571 : : the process of being defined. */
572 : 279 : if (class_template_depth
573 : 279 : || COMPLETE_OR_OPEN_TYPE_P (ctype))
574 : : {
575 : 268 : if (DECL_TEMPLATE_INFO (decl))
576 : : /* DECL is a template specialization. No need to
577 : : build a new TEMPLATE_DECL. */
578 : : ;
579 : 252 : else if (class_template_depth)
580 : : /* We rely on tsubst_friend_function to check the
581 : : validity of the declaration later. */
582 : 97 : decl = push_template_decl (decl, /*is_friend=*/true);
583 : : else
584 : 190 : decl = check_classfn (ctype, decl,
585 : : template_member_p
586 : 35 : ? current_template_parms
587 : : : NULL_TREE);
588 : :
589 : 268 : if ((template_member_p
590 : : /* Always pull out the TEMPLATE_DECL if we have a friend
591 : : template in a class template so that it gets tsubsted
592 : : properly later on (59956). tsubst_friend_function knows
593 : : how to tell this apart from a member template. */
594 : 225 : || (class_template_depth && friend_depth))
595 : 75 : && decl && TREE_CODE (decl) == FUNCTION_DECL)
596 : 40 : decl = DECL_TI_TEMPLATE (decl);
597 : : }
598 : : else
599 : 11 : error ("member %qD declared as friend before type %qT defined",
600 : : decl, ctype);
601 : : }
602 : : else
603 : : {
604 : : /* Namespace-scope friend function. */
605 : :
606 : 3374180 : if (funcdef_flag)
607 : 2204676 : SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
608 : :
609 : 3374180 : if (! DECL_USE_TEMPLATE (decl))
610 : : {
611 : : /* We must check whether the decl refers to template
612 : : arguments before push_template_decl adds a reference to
613 : : the containing template class. */
614 : 3363068 : int warn = (warn_nontemplate_friend
615 : 3363013 : && ! funcdef_flag && ! friend_depth
616 : 186429 : && current_template_parms
617 : 3374025 : && uses_template_parms (decl));
618 : :
619 : 3363068 : if (friend_depth || class_template_depth)
620 : : /* We can't call pushdecl for a template class, since in
621 : : general, such a declaration depends on template
622 : : parameters. Instead, we call pushdecl when the class
623 : : is instantiated. */
624 : 2470303 : decl = push_template_decl (decl, /*is_friend=*/true);
625 : 892765 : else if (current_function_decl && !in_namespace)
626 : : /* pushdecl will check there's a local decl already. */
627 : 16 : decl = pushdecl (decl, /*hiding=*/true);
628 : : else
629 : : {
630 : : /* We can't use pushdecl, as we might be in a template
631 : : class specialization, and pushdecl will insert an
632 : : unqualified friend decl into the template parameter
633 : : scope, rather than the namespace containing it. */
634 : 892749 : tree ns = decl_namespace_context (decl);
635 : :
636 : 892749 : push_nested_namespace (ns);
637 : 892749 : decl = pushdecl_namespace_level (decl, /*hiding=*/true);
638 : 892749 : pop_nested_namespace (ns);
639 : : }
640 : :
641 : 3363068 : if (warn)
642 : : {
643 : 20 : static int explained;
644 : 20 : bool warned;
645 : :
646 : 20 : auto_diagnostic_group d;
647 : 20 : warned = warning (OPT_Wnon_template_friend, "friend declaration "
648 : : "%q#D declares a non-template function", decl);
649 : 20 : if (! explained && warned)
650 : : {
651 : 16 : inform (input_location, "(if this is not what you intended, "
652 : : "make sure the function template has already been "
653 : : "declared and add %<<>%> after the function name "
654 : : "here)");
655 : 16 : explained = 1;
656 : : }
657 : 20 : }
658 : : }
659 : : }
660 : :
661 : 3374459 : if (decl == error_mark_node)
662 : : return error_mark_node;
663 : :
664 : 1170315 : if (!class_template_depth && DECL_IMPLICIT_INSTANTIATION (decl)
665 : 3374494 : && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
666 : : /* "[if no non-template match is found,] each remaining function template
667 : : is replaced with the specialization chosen by deduction from the
668 : : friend declaration or discarded if deduction fails."
669 : :
670 : : set_decl_namespace or check_classfn set DECL_IMPLICIT_INSTANTIATION to
671 : : indicate that we need a template match, so ask
672 : : check_explicit_specialization to find one. */
673 : 83 : decl = (check_explicit_specialization
674 : 83 : (orig_declarator, decl, ctype_depth,
675 : 83 : 2 * funcdef_flag + 4));
676 : :
677 : 8023730 : add_friend (current_class_type,
678 : 3374403 : (!ctype && friend_depth) ? DECL_TI_TEMPLATE (decl) : decl,
679 : : /*complain=*/true);
680 : :
681 : 3374403 : return decl;
682 : : }
683 : :
684 : : #include "gt-cp-friend.h"
|