gcc/cp/friend.c

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