1 /* Help friends in C++. 2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 3 2007, 2008 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 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 3, or (at your option) 10 any later version. 11 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. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "tm.h" 25 #include "tree.h" 26 #include "rtl.h" 27 #include "expr.h" 28 #include "cp-tree.h" 29 #include "flags.h" 30 #include "output.h" 31 #include "toplev.h" 32 33 /* Friend data structures are described in cp-tree.h. */ 34 35 /* Returns nonzero if SUPPLICANT is a friend of TYPE. */ 36 37 int 38 is_friend (tree type, tree supplicant) 39 { 40 int declp; 41 tree list; 42 tree context; 43 44 if (supplicant == NULL_TREE || type == NULL_TREE) 45 return 0; 46 47 declp = DECL_P (supplicant); 48 49 if (declp) 50 /* It's a function decl. */ 51 { 52 tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); 53 tree name = DECL_NAME (supplicant); 54 55 for (; list ; list = TREE_CHAIN (list)) 56 { 57 if (name == FRIEND_NAME (list)) 58 { 59 tree friends = FRIEND_DECLS (list); 60 for (; friends ; friends = TREE_CHAIN (friends)) 61 { 62 tree this_friend = TREE_VALUE (friends); 63 64 if (this_friend == NULL_TREE) 65 continue; 66 67 if (supplicant == this_friend) 68 return 1; 69 70 if (is_specialization_of_friend (supplicant, this_friend)) 71 return 1; 72 } 73 break; 74 } 75 } 76 } 77 else 78 /* It's a type. */ 79 { 80 if (same_type_p (supplicant, type)) 81 return 1; 82 83 list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type))); 84 for (; list ; list = TREE_CHAIN (list)) 85 { 86 tree t = TREE_VALUE (list); 87 88 if (TREE_CODE (t) == TEMPLATE_DECL ? 89 is_specialization_of_friend (TYPE_MAIN_DECL (supplicant), t) : 90 same_type_p (supplicant, t)) 91 return 1; 92 } 93 } 94 95 if (declp) 96 { 97 if (DECL_FUNCTION_MEMBER_P (supplicant)) 98 context = DECL_CONTEXT (supplicant); 99 else 100 context = NULL_TREE; 101 } 102 else 103 { 104 if (TYPE_CLASS_SCOPE_P (supplicant)) 105 /* Nested classes get the same access as their enclosing types, as 106 per DR 45 (this is a change from the standard). */ 107 context = TYPE_CONTEXT (supplicant); 108 else 109 /* Local classes have the same access as the enclosing function. */ 110 context = decl_function_context (TYPE_MAIN_DECL (supplicant)); 111 } 112 113 /* A namespace is not friend to anybody. */ 114 if (context && TREE_CODE (context) == NAMESPACE_DECL) 115 context = NULL_TREE; 116 117 if (context) 118 return is_friend (type, context); 119 120 return 0; 121 } 122 123 /* Add a new friend to the friends of the aggregate type TYPE. 124 DECL is the FUNCTION_DECL of the friend being added. 125 126 If COMPLAIN is true, warning about duplicate friend is issued. 127 We want to have this diagnostics during parsing but not 128 when a template is being instantiated. */ 129 130 void 131 add_friend (tree type, tree decl, bool complain) 132 { 133 tree typedecl; 134 tree list; 135 tree name; 136 tree ctx; 137 138 if (decl == error_mark_node) 139 return; 140 141 typedecl = TYPE_MAIN_DECL (type); 142 list = DECL_FRIENDLIST (typedecl); 143 name = DECL_NAME (decl); 144 type = TREE_TYPE (typedecl); 145 146 while (list) 147 { 148 if (name == FRIEND_NAME (list)) 149 { 150 tree friends = FRIEND_DECLS (list); 151 for (; friends ; friends = TREE_CHAIN (friends)) 152 { 153 if (decl == TREE_VALUE (friends)) 154 { 155 if (complain) 156 warning (0, "%qD is already a friend of class %qT", 157 decl, type); 158 return; 159 } 160 } 161 162 maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1); 163 164 TREE_VALUE (list) = tree_cons (NULL_TREE, decl, 165 TREE_VALUE (list)); 166 return; 167 } 168 list = TREE_CHAIN (list); 169 } 170 171 ctx = DECL_CONTEXT (decl); 172 if (ctx && CLASS_TYPE_P (ctx) && !uses_template_parms (ctx)) 173 perform_or_defer_access_check (TYPE_BINFO (ctx), decl, decl); 174 175 maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1); 176 177 DECL_FRIENDLIST (typedecl) 178 = tree_cons (DECL_NAME (decl), build_tree_list (NULL_TREE, decl), 179 DECL_FRIENDLIST (typedecl)); 180 if (!uses_template_parms (type)) 181 DECL_BEFRIENDING_CLASSES (decl) 182 = tree_cons (NULL_TREE, type, 183 DECL_BEFRIENDING_CLASSES (decl)); 184 } 185 186 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already 187 been defined, we make all of its member functions friends of 188 TYPE. If not, we make it a pending friend, which can later be added 189 when its definition is seen. If a type is defined, then its TYPE_DECL's 190 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend 191 classes that are not defined. If a type has not yet been defined, 192 then the DECL_WAITING_FRIENDS contains a list of types 193 waiting to make it their friend. Note that these two can both 194 be in use at the same time! 195 196 If COMPLAIN is true, warning about duplicate friend is issued. 197 We want to have this diagnostics during parsing but not 198 when a template is being instantiated. */ 199 200 void 201 make_friend_class (tree type, tree friend_type, bool complain) 202 { 203 tree classes; 204 205 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for 206 the enclosing class. FRIEND_DEPTH counts the number of template 207 headers used for this friend declaration. TEMPLATE_MEMBER_P, 208 defined inside the `if' block for TYPENAME_TYPE case, is true if 209 a template header in FRIEND_DEPTH is intended for DECLARATOR. 210 For example, the code 211 212 template <class T> struct A { 213 template <class U> struct B { 214 template <class V> template <class W> 215 friend class C<V>::D; 216 }; 217 }; 218 219 will eventually give the following results 220 221 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U'). 222 2. FRIEND_DEPTH equals 2 (for `V' and `W'). 223 3. TEMPLATE_MEMBER_P is true (for `W'). 224 225 The friend is a template friend iff FRIEND_DEPTH is nonzero. */ 226 227 int class_template_depth = template_class_depth (type); 228 int friend_depth = processing_template_decl - class_template_depth; 229 230 if (! MAYBE_CLASS_TYPE_P (friend_type)) 231 { 232 error ("invalid type %qT declared %<friend%>", friend_type); 233 return; 234 } 235 236 if (friend_depth) 237 /* If the TYPE is a template then it makes sense for it to be 238 friends with itself; this means that each instantiation is 239 friends with all other instantiations. */ 240 { 241 if (CLASS_TYPE_P (friend_type) 242 && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type) 243 && uses_template_parms (friend_type)) 244 { 245 /* [temp.friend] 246 Friend declarations shall not declare partial 247 specializations. */ 248 error ("partial specialization %qT declared %<friend%>", 249 friend_type); 250 return; 251 } 252 } 253 else if (same_type_p (type, friend_type)) 254 { 255 if (complain) 256 warning (0, "class %qT is implicitly friends with itself", 257 type); 258 return; 259 } 260 261 /* [temp.friend] 262 263 A friend of a class or class template can be a function or 264 class template, a specialization of a function template or 265 class template, or an ordinary (nontemplate) function or 266 class. */ 267 if (!friend_depth) 268 ;/* ok */ 269 else if (TREE_CODE (friend_type) == TYPENAME_TYPE) 270 { 271 if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type)) 272 == TEMPLATE_ID_EXPR) 273 { 274 /* template <class U> friend class T::X<U>; */ 275 /* [temp.friend] 276 Friend declarations shall not declare partial 277 specializations. */ 278 error ("partial specialization %qT declared %<friend%>", 279 friend_type); 280 return; 281 } 282 else 283 { 284 /* We will figure this out later. */ 285 bool template_member_p = false; 286 287 tree ctype = TYPE_CONTEXT (friend_type); 288 tree name = TYPE_IDENTIFIER (friend_type); 289 tree decl; 290 291 if (!uses_template_parms_level (ctype, class_template_depth 292 + friend_depth)) 293 template_member_p = true; 294 295 if (class_template_depth) 296 { 297 /* We rely on tsubst_friend_class to check the 298 validity of the declaration later. */ 299 if (template_member_p) 300 friend_type 301 = make_unbound_class_template (ctype, 302 name, 303 current_template_parms, 304 tf_error); 305 else 306 friend_type 307 = make_typename_type (ctype, name, class_type, tf_error); 308 } 309 else 310 { 311 decl = lookup_member (ctype, name, 0, true); 312 if (!decl) 313 { 314 error ("%qT is not a member of %qT", name, ctype); 315 return; 316 } 317 if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl)) 318 { 319 error ("%qT is not a member class template of %qT", 320 name, ctype); 321 error ("%q+D declared here", decl); 322 return; 323 } 324 if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL 325 || !CLASS_TYPE_P (TREE_TYPE (decl)))) 326 { 327 error ("%qT is not a nested class of %qT", 328 name, ctype); 329 error ("%q+D declared here", decl); 330 return; 331 } 332 333 friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)); 334 } 335 } 336 } 337 else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM) 338 { 339 /* template <class T> friend class T; */ 340 error ("template parameter type %qT declared %<friend%>", friend_type); 341 return; 342 } 343 else if (!CLASSTYPE_TEMPLATE_INFO (friend_type)) 344 { 345 /* template <class T> friend class A; where A is not a template */ 346 error ("%q#T is not a template", friend_type); 347 return; 348 } 349 else 350 /* template <class T> friend class A; where A is a template */ 351 friend_type = CLASSTYPE_TI_TEMPLATE (friend_type); 352 353 if (friend_type == error_mark_node) 354 return; 355 356 /* See if it is already a friend. */ 357 for (classes = CLASSTYPE_FRIEND_CLASSES (type); 358 classes; 359 classes = TREE_CHAIN (classes)) 360 { 361 tree probe = TREE_VALUE (classes); 362 363 if (TREE_CODE (friend_type) == TEMPLATE_DECL) 364 { 365 if (friend_type == probe) 366 { 367 if (complain) 368 warning (0, "%qD is already a friend of %qT", probe, type); 369 break; 370 } 371 } 372 else if (TREE_CODE (probe) != TEMPLATE_DECL) 373 { 374 if (same_type_p (probe, friend_type)) 375 { 376 if (complain) 377 warning (0, "%qT is already a friend of %qT", probe, type); 378 break; 379 } 380 } 381 } 382 383 if (!classes) 384 { 385 maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1); 386 387 CLASSTYPE_FRIEND_CLASSES (type) 388 = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type)); 389 if (TREE_CODE (friend_type) == TEMPLATE_DECL) 390 friend_type = TREE_TYPE (friend_type); 391 if (!uses_template_parms (type)) 392 CLASSTYPE_BEFRIENDING_CLASSES (friend_type) 393 = tree_cons (NULL_TREE, type, 394 CLASSTYPE_BEFRIENDING_CLASSES (friend_type)); 395 } 396 } 397 398 /* Record DECL (a FUNCTION_DECL) as a friend of the 399 CURRENT_CLASS_TYPE. If DECL is a member function, CTYPE is the 400 class of which it is a member, as named in the friend declaration. 401 DECLARATOR is the name of the friend. FUNCDEF_FLAG is true if the 402 friend declaration is a definition of the function. FLAGS is as 403 for grokclass fn. */ 404 405 tree 406 do_friend (tree ctype, tree declarator, tree decl, 407 tree attrlist, enum overload_flags flags, 408 bool funcdef_flag) 409 { 410 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); 411 gcc_assert (!ctype || MAYBE_CLASS_TYPE_P (ctype)); 412 413 /* Every decl that gets here is a friend of something. */ 414 DECL_FRIEND_P (decl) = 1; 415 416 /* Unfortunately, we have to handle attributes here. Normally we would 417 handle them in start_decl_1, but since this is a friend decl start_decl_1 418 never gets to see it. */ 419 420 /* Set attributes here so if duplicate decl, will have proper attributes. */ 421 cplus_decl_attributes (&decl, attrlist, 0); 422 423 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) 424 { 425 declarator = TREE_OPERAND (declarator, 0); 426 if (is_overloaded_fn (declarator)) 427 declarator = DECL_NAME (get_first_fn (declarator)); 428 } 429 430 if (ctype) 431 { 432 /* CLASS_TEMPLATE_DEPTH counts the number of template headers for 433 the enclosing class. FRIEND_DEPTH counts the number of template 434 headers used for this friend declaration. TEMPLATE_MEMBER_P is 435 true if a template header in FRIEND_DEPTH is intended for 436 DECLARATOR. For example, the code 437 438 template <class T> struct A { 439 template <class U> struct B { 440 template <class V> template <class W> 441 friend void C<V>::f(W); 442 }; 443 }; 444 445 will eventually give the following results 446 447 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U'). 448 2. FRIEND_DEPTH equals 2 (for `V' and `W'). 449 3. TEMPLATE_MEMBER_P is true (for `W'). */ 450 451 int class_template_depth = template_class_depth (current_class_type); 452 int friend_depth = processing_template_decl - class_template_depth; 453 /* We will figure this out later. */ 454 bool template_member_p = false; 455 456 tree cname = TYPE_NAME (ctype); 457 if (TREE_CODE (cname) == TYPE_DECL) 458 cname = DECL_NAME (cname); 459 460 /* A method friend. */ 461 if (flags == NO_SPECIAL && declarator == cname) 462 DECL_CONSTRUCTOR_P (decl) = 1; 463 464 grokclassfn (ctype, decl, flags); 465 466 if (friend_depth) 467 { 468 if (!uses_template_parms_level (ctype, class_template_depth 469 + friend_depth)) 470 template_member_p = true; 471 } 472 473 /* A nested class may declare a member of an enclosing class 474 to be a friend, so we do lookup here even if CTYPE is in 475 the process of being defined. */ 476 if (class_template_depth 477 || COMPLETE_TYPE_P (ctype) 478 || (CLASS_TYPE_P (ctype) && TYPE_BEING_DEFINED (ctype))) 479 { 480 if (DECL_TEMPLATE_INFO (decl)) 481 /* DECL is a template specialization. No need to 482 build a new TEMPLATE_DECL. */ 483 ; 484 else if (class_template_depth) 485 /* We rely on tsubst_friend_function to check the 486 validity of the declaration later. */ 487 decl = push_template_decl_real (decl, /*is_friend=*/true); 488 else 489 decl = check_classfn (ctype, decl, 490 template_member_p 491 ? current_template_parms 492 : NULL_TREE); 493 494 if (template_member_p && decl && TREE_CODE (decl) == FUNCTION_DECL) 495 decl = DECL_TI_TEMPLATE (decl); 496 497 if (decl) 498 add_friend (current_class_type, decl, /*complain=*/true); 499 } 500 else 501 error ("member %qD declared as friend before type %qT defined", 502 decl, ctype); 503 } 504 /* A global friend. 505 @@ or possibly a friend from a base class ?!? */ 506 else if (TREE_CODE (decl) == FUNCTION_DECL) 507 { 508 int is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P (); 509 510 /* Friends must all go through the overload machinery, 511 even though they may not technically be overloaded. 512 513 Note that because classes all wind up being top-level 514 in their scope, their friend wind up in top-level scope as well. */ 515 if (funcdef_flag) 516 SET_DECL_FRIEND_CONTEXT (decl, current_class_type); 517 518 if (! DECL_USE_TEMPLATE (decl)) 519 { 520 /* We must check whether the decl refers to template 521 arguments before push_template_decl_real adds a 522 reference to the containing template class. */ 523 int warn = (warn_nontemplate_friend 524 && ! funcdef_flag && ! is_friend_template 525 && current_template_parms 526 && uses_template_parms (decl)); 527 528 if (is_friend_template 529 || template_class_depth (current_class_type) != 0) 530 /* We can't call pushdecl for a template class, since in 531 general, such a declaration depends on template 532 parameters. Instead, we call pushdecl when the class 533 is instantiated. */ 534 decl = push_template_decl_real (decl, /*is_friend=*/true); 535 else if (current_function_decl) 536 { 537 /* This must be a local class. 11.5p11: 538 539 If a friend declaration appears in a local class (9.8) and 540 the name specified is an unqualified name, a prior 541 declaration is looked up without considering scopes that 542 are outside the innermost enclosing non-class scope. For a 543 friend function declaration, if there is no prior 544 declaration, the program is ill-formed. */ 545 tree t = lookup_name_innermost_nonclass_level (DECL_NAME (decl)); 546 if (t) 547 decl = pushdecl_maybe_friend (decl, /*is_friend=*/true); 548 else 549 { 550 error ("friend declaration %qD in local class without " 551 "prior declaration", decl); 552 return error_mark_node; 553 } 554 } 555 else 556 { 557 /* We can't use pushdecl, as we might be in a template 558 class specialization, and pushdecl will insert an 559 unqualified friend decl into the template parameter 560 scope, rather than the namespace containing it. */ 561 tree ns = decl_namespace_context (decl); 562 563 push_nested_namespace (ns); 564 decl = pushdecl_namespace_level (decl, /*is_friend=*/true); 565 pop_nested_namespace (ns); 566 } 567 568 if (warn) 569 { 570 static int explained; 571 bool warned; 572 573 warned = warning (OPT_Wnon_template_friend, "friend declaration " 574 "%q#D declares a non-template function", decl); 575 if (! explained && warned) 576 { 577 inform (input_location, "(if this is not what you intended, make sure " 578 "the function template has already been declared " 579 "and add <> after the function name here) "); 580 explained = 1; 581 } 582 } 583 } 584 585 if (decl == error_mark_node) 586 return error_mark_node; 587 588 add_friend (current_class_type, 589 is_friend_template ? DECL_TI_TEMPLATE (decl) : decl, 590 /*complain=*/true); 591 DECL_FRIEND_P (decl) = 1; 592 } 593 594 return decl; 595 } 596