Line data Source code
1 : /* Help friends in C++.
2 : Copyright (C) 1997-2023 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 47349271 : is_global_friend (tree scope)
52 : {
53 47349271 : gcc_checking_assert (scope != NULL_TREE);
54 :
55 47349271 : if (global_friend == scope)
56 : return true;
57 :
58 47349271 : 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 19617464 : is_friend (tree type, tree supplicant)
71 : {
72 37047319 : int declp;
73 37047319 : tree list;
74 37047319 : tree context;
75 :
76 37047319 : if (supplicant == NULL_TREE || type == NULL_TREE)
77 : return 0;
78 :
79 37047319 : if (is_global_friend (supplicant))
80 : return 1;
81 :
82 37047319 : declp = DECL_P (supplicant);
83 :
84 37047319 : if (declp)
85 : /* It's a function decl. */
86 : {
87 17406576 : tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
88 17406576 : tree name = DECL_NAME (supplicant);
89 :
90 36220899 : for (; list ; list = TREE_CHAIN (list))
91 : {
92 19325382 : if (name == FRIEND_NAME (list))
93 : {
94 511059 : tree friends = FRIEND_DECLS (list);
95 654874 : for (; friends ; friends = TREE_CHAIN (friends))
96 : {
97 536399 : tree this_friend = TREE_VALUE (friends);
98 :
99 536399 : if (this_friend == NULL_TREE)
100 0 : continue;
101 :
102 536399 : if (supplicant == this_friend)
103 : return 1;
104 :
105 209331 : 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 19640743 : if (same_type_p (supplicant, type))
116 : return 1;
117 :
118 1042957 : list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type)));
119 1231419 : for (; list ; list = TREE_CHAIN (list))
120 : {
121 773338 : tree t = TREE_VALUE (list);
122 :
123 1546676 : if (TREE_CODE (t) == TEMPLATE_DECL ?
124 473429 : is_specialization_of_friend (TYPE_MAIN_DECL (supplicant), t) :
125 299909 : same_type_p (supplicant, t))
126 : return 1;
127 : }
128 : }
129 :
130 17472073 : if (declp)
131 : {
132 17013992 : if (DECL_FUNCTION_MEMBER_P (supplicant))
133 17012586 : context = DECL_CONTEXT (supplicant);
134 2812 : else if (tree fc = DECL_FRIEND_CONTEXT (supplicant))
135 : context = fc;
136 : else
137 : context = NULL_TREE;
138 : }
139 : else
140 : {
141 458081 : 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 364574 : context = TYPE_CONTEXT (supplicant);
145 : else
146 : /* Local classes have the same access as the enclosing function. */
147 93507 : context = decl_function_context (TYPE_MAIN_DECL (supplicant));
148 : }
149 :
150 : /* A namespace is not friend to anybody. */
151 17470721 : 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 3197443 : add_friend (tree type, tree decl, bool complain)
169 : {
170 3197443 : tree typedecl;
171 3197443 : tree list;
172 3197443 : tree name;
173 3197443 : tree ctx;
174 :
175 3197443 : if (decl == error_mark_node)
176 : return;
177 :
178 3196287 : typedecl = TYPE_MAIN_DECL (type);
179 3196287 : list = DECL_FRIENDLIST (typedecl);
180 3196287 : name = DECL_NAME (decl);
181 3196287 : type = TREE_TYPE (typedecl);
182 :
183 6946808 : while (list)
184 : {
185 4036947 : if (name == FRIEND_NAME (list))
186 : {
187 286426 : tree friends = FRIEND_DECLS (list);
188 750319 : for (; friends ; friends = TREE_CHAIN (friends))
189 : {
190 463976 : 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 286343 : TREE_VALUE (list) = tree_cons (NULL_TREE, decl,
201 286343 : TREE_VALUE (list));
202 286343 : break;
203 : }
204 3750521 : list = TREE_CHAIN (list);
205 : }
206 :
207 3196204 : ctx = DECL_CONTEXT (decl);
208 3196204 : if (ctx && CLASS_TYPE_P (ctx) && !uses_template_parms (ctx))
209 132 : perform_or_defer_access_check (TYPE_BINFO (ctx), decl, decl,
210 : tf_warning_or_error);
211 :
212 3196204 : maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
213 :
214 3196204 : if (!list)
215 2909861 : DECL_FRIENDLIST (typedecl)
216 5819722 : = tree_cons (DECL_NAME (decl), build_tree_list (NULL_TREE, decl),
217 2909861 : DECL_FRIENDLIST (typedecl));
218 3196204 : if (!uses_template_parms (type))
219 1754662 : DECL_BEFRIENDING_CLASSES (decl)
220 1754662 : = tree_cons (NULL_TREE, type,
221 1754662 : 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 1595653 : make_friend_class (tree type, tree friend_type, bool complain)
240 : {
241 1595653 : 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 1595653 : int class_template_depth = template_class_depth (type);
266 1595653 : int friend_depth = 0;
267 1595653 : 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 714738 : 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 880915 : gcc_checking_assert (class_template_depth == 0);
277 1274672 : while (uses_template_parms_level (friend_type, friend_depth + 1))
278 : ++friend_depth;
279 : }
280 :
281 1595442 : if (! MAYBE_CLASS_TYPE_P (friend_type)
282 1595674 : && 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 1595635 : friend_type = cv_unqualified (friend_type);
296 :
297 1595635 : if (check_for_bare_parameter_packs (friend_type))
298 : return;
299 :
300 1595632 : if (friend_depth)
301 : {
302 : /* [temp.friend] Friend declarations shall not declare partial
303 : specializations. */
304 754992 : if (CLASS_TYPE_P (friend_type)
305 754992 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type)
306 755081 : && uses_template_parms (friend_type))
307 : {
308 0 : error ("partial specialization %qT declared %<friend%>",
309 : friend_type);
310 0 : return;
311 : }
312 :
313 755077 : if (TYPE_TEMPLATE_INFO (friend_type)
314 2264976 : && !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 840555 : 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 1595620 : if (!friend_depth)
346 : ;/* ok */
347 755073 : 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 754991 : 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 754991 : else if (TREE_CODE (friend_type) == TEMPLATE_TEMPLATE_PARM)
431 3 : friend_type = TYPE_NAME (friend_type);
432 754988 : 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 754988 : friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
441 :
442 1595620 : if (friend_type == error_mark_node)
443 : return;
444 :
445 : /* See if it is already a friend. */
446 1595620 : for (classes = CLASSTYPE_FRIEND_CLASSES (type);
447 2486957 : classes;
448 891337 : classes = TREE_CHAIN (classes))
449 : {
450 891343 : tree probe = TREE_VALUE (classes);
451 :
452 891343 : if (TREE_CODE (friend_type) == TEMPLATE_DECL)
453 : {
454 445114 : 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 446229 : else if (TREE_CODE (probe) != TEMPLATE_DECL)
463 : {
464 367101 : if (same_type_p (probe, friend_type))
465 : {
466 4 : if (complain)
467 0 : warning (OPT_Wredundant_decls,
468 : "%qT is already a friend of %qT", probe, type);
469 : break;
470 : }
471 : }
472 : }
473 :
474 1595620 : if (!classes)
475 : {
476 1595614 : maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1);
477 :
478 1595614 : CLASSTYPE_FRIEND_CLASSES (type)
479 1595614 : = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
480 1595614 : if (TREE_CODE (friend_type) == TEMPLATE_DECL)
481 755043 : friend_type = TREE_TYPE (friend_type);
482 1595614 : if (!uses_template_parms (type))
483 925352 : CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
484 925352 : = tree_cons (NULL_TREE, type,
485 925352 : 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 2022691 : do_friend (tree scope, tree declarator, tree decl,
500 : enum overload_flags flags,
501 : bool funcdef_flag)
502 : {
503 2022691 : gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
504 :
505 2022691 : tree ctype = NULL_TREE;
506 2022691 : tree in_namespace = NULL_TREE;
507 2022691 : if (!scope)
508 : ;
509 59938 : else if (MAYBE_CLASS_TYPE_P (scope))
510 : ctype = scope;
511 : else
512 : {
513 59661 : gcc_checking_assert (TREE_CODE (scope) == NAMESPACE_DECL);
514 : in_namespace = scope;
515 : }
516 :
517 : /* Friend functions are unique, until proved otherwise. */
518 2022691 : DECL_UNIQUE_FRIEND_P (decl) = 1;
519 :
520 4045379 : if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl))
521 6 : error ("friend declaration %qD may not have virt-specifiers",
522 : decl);
523 :
524 2022691 : tree orig_declarator = declarator;
525 2022691 : if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
526 : {
527 8429 : declarator = TREE_OPERAND (declarator, 0);
528 16855 : if (!identifier_p (declarator))
529 8423 : 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 2022691 : int class_template_depth = template_class_depth (current_class_type);
553 2022691 : int friend_depth = current_template_depth - class_template_depth;
554 2022691 : int ctype_depth = num_template_headers_for_class (ctype);
555 2022691 : bool template_member_p = friend_depth > ctype_depth;
556 :
557 2022691 : if (ctype)
558 : {
559 277 : tree cname = TYPE_NAME (ctype);
560 277 : if (TREE_CODE (cname) == TYPE_DECL)
561 277 : cname = DECL_NAME (cname);
562 :
563 : /* A method friend. */
564 277 : if (flags == NO_SPECIAL && declarator == cname)
565 28 : DECL_CXX_CONSTRUCTOR_P (decl) = 1;
566 :
567 277 : 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 277 : if (class_template_depth
573 277 : || COMPLETE_OR_OPEN_TYPE_P (ctype))
574 : {
575 266 : if (DECL_TEMPLATE_INFO (decl))
576 : /* DECL is a template specialization. No need to
577 : build a new TEMPLATE_DECL. */
578 : ;
579 250 : 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 188 : decl = check_classfn (ctype, decl,
585 : template_member_p
586 35 : ? current_template_parms
587 : : NULL_TREE);
588 :
589 266 : 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 223 : || (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 2022414 : if (funcdef_flag)
607 1241164 : SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
608 :
609 2022414 : 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 2013990 : int warn = (warn_nontemplate_friend
615 2013935 : && ! funcdef_flag && ! friend_depth
616 72947 : && current_template_parms
617 2022257 : && uses_template_parms (decl));
618 :
619 2013990 : 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 1589832 : decl = push_template_decl (decl, /*is_friend=*/true);
625 424158 : 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 424142 : tree ns = decl_namespace_context (decl);
635 :
636 424142 : push_nested_namespace (ns);
637 424142 : decl = pushdecl_namespace_level (decl, /*hiding=*/true);
638 424142 : pop_nested_namespace (ns);
639 : }
640 :
641 2013990 : 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 2022691 : if (decl == error_mark_node)
662 : return error_mark_node;
663 :
664 581093 : if (!class_template_depth && DECL_IMPLICIT_INSTANTIATION (decl)
665 2022726 : && 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 4884955 : add_friend (current_class_type,
678 2022635 : (!ctype && friend_depth) ? DECL_TI_TEMPLATE (decl) : decl,
679 : /*complain=*/true);
680 :
681 2022635 : return decl;
682 : }
683 :
684 : #include "gt-cp-friend.h"
|
