1 /* Help friends in C++. 2 Copyright (C) 1997-2018 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 set_global_friend (tree scope) 42 { 43 gcc_checking_assert (scope != NULL_TREE); 44 gcc_assert (!global_friend || global_friend == scope); 45 global_friend = scope; 46 } 47 48 /* Return TRUE if SCOPE is the global friend. */ 49 50 bool 51 is_global_friend (tree scope) 52 { 53 gcc_checking_assert (scope != NULL_TREE); 54 55 if (global_friend == scope) 56 return true; 57 58 if (!global_friend) 59 return false; 60 61 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 is_friend (tree type, tree supplicant) 71 { 72 int declp; 73 tree list; 74 tree context; 75 76 if (supplicant == NULL_TREE || type == NULL_TREE) 77 return 0; 78 79 if (is_global_friend (supplicant)) 80 return 1; 81 82 declp = DECL_P (supplicant); 83 84 if (declp) 85 /* It's a function decl. */ 86 { 87 tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); 88 tree name = DECL_NAME (supplicant); 89 90 for (; list ; list = TREE_CHAIN (list)) 91 { 92 if (name == FRIEND_NAME (list)) 93 { 94 tree friends = FRIEND_DECLS (list); 95 for (; friends ; friends = TREE_CHAIN (friends)) 96 { 97 tree this_friend = TREE_VALUE (friends); 98 99 if (this_friend == NULL_TREE) 100 continue; 101 102 if (supplicant == this_friend) 103 return 1; 104 105 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 if (same_type_p (supplicant, type)) 116 return 1; 117 118 list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type))); 119 for (; list ; list = TREE_CHAIN (list)) 120 { 121 tree t = TREE_VALUE (list); 122 123 if (TREE_CODE (t) == TEMPLATE_DECL ? 124 is_specialization_of_friend (TYPE_MAIN_DECL (supplicant), t) : 125 same_type_p (supplicant, t)) 126 return 1; 127 } 128 } 129 130 if (declp) 131 { 132 if (DECL_FUNCTION_MEMBER_P (supplicant)) 133 context = DECL_CONTEXT (supplicant); 134 else 135 context = NULL_TREE; 136 } 137 else 138 { 139 if (TYPE_CLASS_SCOPE_P (supplicant)) 140 /* Nested classes get the same access as their enclosing types, as 141 per DR 45 (this is a change from the standard). */ 142 context = TYPE_CONTEXT (supplicant); 143 else 144 /* Local classes have the same access as the enclosing function. */ 145 context = decl_function_context (TYPE_MAIN_DECL (supplicant)); 146 } 147 148 /* A namespace is not friend to anybody. */ 149 if (context && TREE_CODE (context) == NAMESPACE_DECL) 150 context = NULL_TREE; 151 152 if (context) 153 return is_friend (type, context); 154 155 return 0; 156 } 157 158 /* Add a new friend to the friends of the aggregate type TYPE. 159 DECL is the FUNCTION_DECL of the friend being added. 160 161 If COMPLAIN is true, warning about duplicate friend is issued. 162 We want to have this diagnostics during parsing but not 163 when a template is being instantiated. */ 164 165 void 166 add_friend (tree type, tree decl, bool complain) 167 { 168 tree typedecl; 169 tree list; 170 tree name; 171 tree ctx; 172 173 if (decl == error_mark_node) 174 return; 175 176 typedecl = TYPE_MAIN_DECL (type); 177 list = DECL_FRIENDLIST (typedecl); 178 name = DECL_NAME (decl); 179 type = TREE_TYPE (typedecl); 180 181 while (list) 182 { 183 if (name == FRIEND_NAME (list)) 184 { 185 tree friends = FRIEND_DECLS (list); 186 for (; friends ; friends = TREE_CHAIN (friends)) 187 { 188 if (decl == TREE_VALUE (friends)) 189 { 190 if (complain) 191 warning (OPT_Wredundant_decls, 192 "%qD is already a friend of class %qT", 193 decl, type); 194 return; 195 } 196 } 197 198 TREE_VALUE (list) = tree_cons (NULL_TREE, decl, 199 TREE_VALUE (list)); 200 break; 201 } 202 list = TREE_CHAIN (list); 203 } 204 205 ctx = DECL_CONTEXT (decl); 206 if (ctx && CLASS_TYPE_P (ctx) && !uses_template_parms (ctx)) 207 perform_or_defer_access_check (TYPE_BINFO (ctx), decl, decl, 208 tf_warning_or_error); 209 210 maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1); 211 212 if (!list) 213 DECL_FRIENDLIST (typedecl) 214 = tree_cons (DECL_NAME (decl), build_tree_list (NULL_TREE, decl), 215 DECL_FRIENDLIST (typedecl)); 216 if (!uses_template_parms (type)) 217 DECL_BEFRIENDING_CLASSES (decl) 218 = tree_cons (NULL_TREE, type, 219 DECL_BEFRIENDING_CLASSES (decl)); 220 } 221 222 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already 223 been defined, we make all of its member functions friends of 224 TYPE. If not, we make it a pending friend, which can later be added 225 when its definition is seen. If a type is defined, then its TYPE_DECL's 226 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend 227 classes that are not defined. If a type has not yet been defined, 228 then the DECL_WAITING_FRIENDS contains a list of types 229 waiting to make it their friend. Note that these two can both 230 be in use at the same time! 231 232 If COMPLAIN is true, warning about duplicate friend is issued. 233 We want to have this diagnostics during parsing but not 234 when a template is being instantiated. */ 235 236 void 237 make_friend_class (tree type, tree friend_type, bool complain) 238 { 239 tree classes; 240 241 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for 242 the enclosing class. FRIEND_DEPTH counts the number of template 243 headers used for this friend declaration. TEMPLATE_MEMBER_P, 244 defined inside the `if' block for TYPENAME_TYPE case, is true if 245 a template header in FRIEND_DEPTH is intended for DECLARATOR. 246 For example, the code 247 248 template <class T> struct A { 249 template <class U> struct B { 250 template <class V> template <class W> 251 friend class C<V>::D; 252 }; 253 }; 254 255 will eventually give the following results 256 257 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U'). 258 2. FRIEND_DEPTH equals 2 (for `V' and `W'). 259 3. TEMPLATE_MEMBER_P is true (for `W'). 260 261 The friend is a template friend iff FRIEND_DEPTH is nonzero. */ 262 263 int class_template_depth = template_class_depth (type); 264 int friend_depth = processing_template_decl - class_template_depth; 265 266 if (! MAYBE_CLASS_TYPE_P (friend_type) 267 && TREE_CODE (friend_type) != TEMPLATE_TEMPLATE_PARM) 268 { 269 /* N1791: If the type specifier in a friend declaration designates a 270 (possibly cv-qualified) class type, that class is declared as a 271 friend; otherwise, the friend declaration is ignored. 272 273 So don't complain in C++11 mode. */ 274 if (cxx_dialect < cxx11) 275 pedwarn (input_location, complain ? 0 : OPT_Wpedantic, 276 "invalid type %qT declared %<friend%>", friend_type); 277 return; 278 } 279 280 friend_type = cv_unqualified (friend_type); 281 282 if (check_for_bare_parameter_packs (friend_type)) 283 return; 284 285 if (friend_depth) 286 { 287 /* [temp.friend] Friend declarations shall not declare partial 288 specializations. */ 289 if (CLASS_TYPE_P (friend_type) 290 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type) 291 && uses_template_parms (friend_type)) 292 { 293 error ("partial specialization %qT declared %<friend%>", 294 friend_type); 295 return; 296 } 297 298 if (TYPE_TEMPLATE_INFO (friend_type) 299 && !PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (friend_type))) 300 { 301 error ("%qT is not a template", friend_type); 302 inform (location_of (friend_type), "previous declaration here"); 303 if (TYPE_CLASS_SCOPE_P (friend_type) 304 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (friend_type)) 305 && currently_open_class (TYPE_CONTEXT (friend_type))) 306 inform (input_location, "perhaps you need explicit template " 307 "arguments in your nested-name-specifier"); 308 return; 309 } 310 } 311 312 /* It makes sense for a template class to be friends with itself, 313 that means the instantiations can be friendly. Other cases are 314 not so meaningful. */ 315 if (!friend_depth && same_type_p (type, friend_type)) 316 { 317 if (complain) 318 warning (0, "class %qT is implicitly friends with itself", 319 type); 320 return; 321 } 322 323 /* [temp.friend] 324 325 A friend of a class or class template can be a function or 326 class template, a specialization of a function template or 327 class template, or an ordinary (nontemplate) function or 328 class. */ 329 if (!friend_depth) 330 ;/* ok */ 331 else if (TREE_CODE (friend_type) == TYPENAME_TYPE) 332 { 333 if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type)) 334 == TEMPLATE_ID_EXPR) 335 { 336 /* template <class U> friend class T::X<U>; */ 337 /* [temp.friend] 338 Friend declarations shall not declare partial 339 specializations. */ 340 error ("partial specialization %qT declared %<friend%>", 341 friend_type); 342 return; 343 } 344 else 345 { 346 /* We will figure this out later. */ 347 bool template_member_p = false; 348 349 tree ctype = TYPE_CONTEXT (friend_type); 350 tree name = TYPE_IDENTIFIER (friend_type); 351 tree decl; 352 353 if (!uses_template_parms_level (ctype, class_template_depth 354 + friend_depth)) 355 template_member_p = true; 356 357 if (class_template_depth) 358 { 359 /* We rely on tsubst_friend_class to check the 360 validity of the declaration later. */ 361 if (template_member_p) 362 friend_type 363 = make_unbound_class_template (ctype, 364 name, 365 current_template_parms, 366 tf_error); 367 else 368 friend_type 369 = make_typename_type (ctype, name, class_type, tf_error); 370 } 371 else 372 { 373 decl = lookup_member (ctype, name, 0, true, tf_warning_or_error); 374 if (!decl) 375 { 376 error ("%qT is not a member of %qT", name, ctype); 377 return; 378 } 379 if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl)) 380 { 381 error ("%qT is not a member class template of %qT", 382 name, ctype); 383 inform (DECL_SOURCE_LOCATION (decl), 384 "%qD declared here", decl); 385 return; 386 } 387 if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL 388 || !CLASS_TYPE_P (TREE_TYPE (decl)))) 389 { 390 error ("%qT is not a nested class of %qT", 391 name, ctype); 392 inform (DECL_SOURCE_LOCATION (decl), 393 "%qD declared here", decl); 394 return; 395 } 396 397 friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)); 398 } 399 } 400 } 401 else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM) 402 { 403 /* template <class T> friend class T; */ 404 error ("template parameter type %qT declared %<friend%>", friend_type); 405 return; 406 } 407 else if (TREE_CODE (friend_type) == TEMPLATE_TEMPLATE_PARM) 408 friend_type = TYPE_NAME (friend_type); 409 else if (!CLASSTYPE_TEMPLATE_INFO (friend_type)) 410 { 411 /* template <class T> friend class A; where A is not a template */ 412 error ("%q#T is not a template", friend_type); 413 return; 414 } 415 else 416 /* template <class T> friend class A; where A is a template */ 417 friend_type = CLASSTYPE_TI_TEMPLATE (friend_type); 418 419 if (friend_type == error_mark_node) 420 return; 421 422 /* See if it is already a friend. */ 423 for (classes = CLASSTYPE_FRIEND_CLASSES (type); 424 classes; 425 classes = TREE_CHAIN (classes)) 426 { 427 tree probe = TREE_VALUE (classes); 428 429 if (TREE_CODE (friend_type) == TEMPLATE_DECL) 430 { 431 if (friend_type == probe) 432 { 433 if (complain) 434 warning (OPT_Wredundant_decls, 435 "%qD is already a friend of %qT", probe, type); 436 break; 437 } 438 } 439 else if (TREE_CODE (probe) != TEMPLATE_DECL) 440 { 441 if (same_type_p (probe, friend_type)) 442 { 443 if (complain) 444 warning (OPT_Wredundant_decls, 445 "%qT is already a friend of %qT", probe, type); 446 break; 447 } 448 } 449 } 450 451 if (!classes) 452 { 453 maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1); 454 455 CLASSTYPE_FRIEND_CLASSES (type) 456 = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type)); 457 if (TREE_CODE (friend_type) == TEMPLATE_DECL) 458 friend_type = TREE_TYPE (friend_type); 459 if (!uses_template_parms (type)) 460 CLASSTYPE_BEFRIENDING_CLASSES (friend_type) 461 = tree_cons (NULL_TREE, type, 462 CLASSTYPE_BEFRIENDING_CLASSES (friend_type)); 463 } 464 } 465 466 /* Record DECL (a FUNCTION_DECL) as a friend of the 467 CURRENT_CLASS_TYPE. If DECL is a member function, CTYPE is the 468 class of which it is a member, as named in the friend declaration. 469 DECLARATOR is the name of the friend. FUNCDEF_FLAG is true if the 470 friend declaration is a definition of the function. FLAGS is as 471 for grokclass fn. */ 472 473 tree 474 do_friend (tree ctype, tree declarator, tree decl, 475 tree attrlist, enum overload_flags flags, 476 bool funcdef_flag) 477 { 478 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); 479 gcc_assert (!ctype || MAYBE_CLASS_TYPE_P (ctype)); 480 481 /* Every decl that gets here is a friend of something. */ 482 DECL_FRIEND_P (decl) = 1; 483 484 if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl)) 485 error ("friend declaration %qD may not have virt-specifiers", 486 decl); 487 488 /* Unfortunately, we have to handle attributes here. Normally we would 489 handle them in start_decl_1, but since this is a friend decl start_decl_1 490 never gets to see it. */ 491 492 /* Set attributes here so if duplicate decl, will have proper attributes. */ 493 cplus_decl_attributes (&decl, attrlist, 0); 494 495 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) 496 { 497 declarator = TREE_OPERAND (declarator, 0); 498 if (!identifier_p (declarator)) 499 declarator = OVL_NAME (declarator); 500 } 501 502 if (ctype) 503 { 504 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for 505 the enclosing class. FRIEND_DEPTH counts the number of template 506 headers used for this friend declaration. TEMPLATE_MEMBER_P is 507 true if a template header in FRIEND_DEPTH is intended for 508 DECLARATOR. For example, the code 509 510 template <class T> struct A { 511 template <class U> struct B { 512 template <class V> template <class W> 513 friend void C<V>::f(W); 514 }; 515 }; 516 517 will eventually give the following results 518 519 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U'). 520 2. FRIEND_DEPTH equals 2 (for `V' and `W'). 521 3. TEMPLATE_MEMBER_P is true (for `W'). */ 522 523 int class_template_depth = template_class_depth (current_class_type); 524 int friend_depth = processing_template_decl - class_template_depth; 525 /* We will figure this out later. */ 526 bool template_member_p = false; 527 528 tree cname = TYPE_NAME (ctype); 529 if (TREE_CODE (cname) == TYPE_DECL) 530 cname = DECL_NAME (cname); 531 532 /* A method friend. */ 533 if (flags == NO_SPECIAL && declarator == cname) 534 DECL_CXX_CONSTRUCTOR_P (decl) = 1; 535 536 grokclassfn (ctype, decl, flags); 537 538 if (friend_depth) 539 { 540 if (!uses_template_parms_level (ctype, class_template_depth 541 + friend_depth)) 542 template_member_p = true; 543 } 544 545 /* A nested class may declare a member of an enclosing class 546 to be a friend, so we do lookup here even if CTYPE is in 547 the process of being defined. */ 548 if (class_template_depth 549 || COMPLETE_OR_OPEN_TYPE_P (ctype)) 550 { 551 if (DECL_TEMPLATE_INFO (decl)) 552 /* DECL is a template specialization. No need to 553 build a new TEMPLATE_DECL. */ 554 ; 555 else if (class_template_depth) 556 /* We rely on tsubst_friend_function to check the 557 validity of the declaration later. */ 558 decl = push_template_decl_real (decl, /*is_friend=*/true); 559 else 560 decl = check_classfn (ctype, decl, 561 template_member_p 562 ? current_template_parms 563 : NULL_TREE); 564 565 if ((template_member_p 566 /* Always pull out the TEMPLATE_DECL if we have a friend 567 template in a class template so that it gets tsubsted 568 properly later on (59956). tsubst_friend_function knows 569 how to tell this apart from a member template. */ 570 || (class_template_depth && friend_depth)) 571 && decl && TREE_CODE (decl) == FUNCTION_DECL) 572 decl = DECL_TI_TEMPLATE (decl); 573 574 if (decl) 575 add_friend (current_class_type, decl, /*complain=*/true); 576 } 577 else 578 error ("member %qD declared as friend before type %qT defined", 579 decl, ctype); 580 } 581 /* A global friend. 582 @@ or possibly a friend from a base class ?!? */ 583 else if (TREE_CODE (decl) == FUNCTION_DECL) 584 { 585 int is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P (); 586 587 /* Friends must all go through the overload machinery, 588 even though they may not technically be overloaded. 589 590 Note that because classes all wind up being top-level 591 in their scope, their friend wind up in top-level scope as well. */ 592 if (funcdef_flag) 593 SET_DECL_FRIEND_CONTEXT (decl, current_class_type); 594 595 if (! DECL_USE_TEMPLATE (decl)) 596 { 597 /* We must check whether the decl refers to template 598 arguments before push_template_decl_real adds a 599 reference to the containing template class. */ 600 int warn = (warn_nontemplate_friend 601 && ! funcdef_flag && ! is_friend_template 602 && current_template_parms 603 && uses_template_parms (decl)); 604 605 if (is_friend_template 606 || template_class_depth (current_class_type) != 0) 607 /* We can't call pushdecl for a template class, since in 608 general, such a declaration depends on template 609 parameters. Instead, we call pushdecl when the class 610 is instantiated. */ 611 decl = push_template_decl_real (decl, /*is_friend=*/true); 612 else if (current_function_decl) 613 /* pushdecl will check there's a local decl already. */ 614 decl = pushdecl (decl, /*is_friend=*/true); 615 else 616 { 617 /* We can't use pushdecl, as we might be in a template 618 class specialization, and pushdecl will insert an 619 unqualified friend decl into the template parameter 620 scope, rather than the namespace containing it. */ 621 tree ns = decl_namespace_context (decl); 622 623 push_nested_namespace (ns); 624 decl = pushdecl_namespace_level (decl, /*is_friend=*/true); 625 pop_nested_namespace (ns); 626 } 627 628 if (warn) 629 { 630 static int explained; 631 bool warned; 632 633 warned = warning (OPT_Wnon_template_friend, "friend declaration " 634 "%q#D declares a non-template function", decl); 635 if (! explained && warned) 636 { 637 inform (input_location, "(if this is not what you intended, make sure " 638 "the function template has already been declared " 639 "and add <> after the function name here) "); 640 explained = 1; 641 } 642 } 643 } 644 645 if (decl == error_mark_node) 646 return error_mark_node; 647 648 add_friend (current_class_type, 649 is_friend_template ? DECL_TI_TEMPLATE (decl) : decl, 650 /*complain=*/true); 651 DECL_FRIEND_P (decl) = 1; 652 } 653 654 return decl; 655 } 656 657 #include "gt-cp-friend.h" 658