contrib/gcc-4.7/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, 2011  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       /* N1791: If the type specifier in a friend declaration designates a
 230          (possibly cv-qualified) class type, that class is declared as a
 231          friend; otherwise, the friend declaration is ignored.
 232
 233          So don't complain in C++0x mode.  */
 234       if (cxx_dialect < cxx0x)
 235         pedwarn (input_location, complain ? 0 : OPT_pedantic,
 236                  "invalid type %qT declared %<friend%>", friend_type);
 237       return;
 238     }
 239
 240   friend_type = cv_unqualified (friend_type);
 241
 242   if (friend_depth)
 243     /* If the TYPE is a template then it makes sense for it to be
 244        friends with itself; this means that each instantiation is
 245        friends with all other instantiations.  */
 246     {
 247       if (CLASS_TYPE_P (friend_type)
 248           && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type)
 249           && uses_template_parms (friend_type))
 250         {
 251           /* [temp.friend]
 252              Friend declarations shall not declare partial
 253              specializations.  */
 254           error ("partial specialization %qT declared %<friend%>",
 255                  friend_type);
 256           return;
 257         }
 258     }
 259   else if (same_type_p (type, friend_type))
 260     {
 261       if (complain)
 262         warning (0, "class %qT is implicitly friends with itself",
 263                  type);
 264       return;
 265     }
 266
 267   /* [temp.friend]
 268
 269      A friend of a class or class template can be a function or
 270      class template, a specialization of a function template or
 271      class template, or an ordinary (nontemplate) function or
 272      class.  */
 273   if (!friend_depth)
 274     ;/* ok */
 275   else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
 276     {
 277       if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type))
 278           == TEMPLATE_ID_EXPR)
 279         {
 280           /* template <class U> friend class T::X<U>; */
 281           /* [temp.friend]
 282              Friend declarations shall not declare partial
 283              specializations.  */
 284           error ("partial specialization %qT declared %<friend%>",
 285                  friend_type);
 286           return;
 287         }
 288       else
 289         {
 290           /* We will figure this out later.  */
 291           bool template_member_p = false;
 292
 293           tree ctype = TYPE_CONTEXT (friend_type);
 294           tree name = TYPE_IDENTIFIER (friend_type);
 295           tree decl;
 296
 297           if (!uses_template_parms_level (ctype, class_template_depth
 298                                                  + friend_depth))
 299             template_member_p = true;
 300
 301           if (class_template_depth)
 302             {
 303               /* We rely on tsubst_friend_class to check the
 304                  validity of the declaration later.  */
 305               if (template_member_p)
 306                 friend_type
 307                   = make_unbound_class_template (ctype,
 308                                                  name,
 309                                                  current_template_parms,
 310                                                  tf_error);
 311               else
 312                 friend_type
 313                   = make_typename_type (ctype, name, class_type, tf_error);
 314             }
 315           else
 316             {
 317               decl = lookup_member (ctype, name, 0, true, tf_warning_or_error);
 318               if (!decl)
 319                 {
 320                   error ("%qT is not a member of %qT", name, ctype);
 321                   return;
 322                 }
 323               if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl))
 324                 {
 325                   error ("%qT is not a member class template of %qT",
 326                          name, ctype);
 327                   error ("%q+D declared here", decl);
 328                   return;
 329                 }
 330               if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL
 331                                          || !CLASS_TYPE_P (TREE_TYPE (decl))))
 332                 {
 333                   error ("%qT is not a nested class of %qT",
 334                          name, ctype);
 335                   error ("%q+D declared here", decl);
 336                   return;
 337                 }
 338
 339               friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl));
 340             }
 341         }
 342     }
 343   else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
 344     {
 345       /* template <class T> friend class T; */
 346       error ("template parameter type %qT declared %<friend%>", friend_type);
 347       return;
 348     }
 349   else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
 350     {
 351       /* template <class T> friend class A; where A is not a template */
 352       error ("%q#T is not a template", friend_type);
 353       return;
 354     }
 355   else
 356     /* template <class T> friend class A; where A is a template */
 357     friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
 358
 359   if (friend_type == error_mark_node)
 360     return;
 361
 362   /* See if it is already a friend.  */
 363   for (classes = CLASSTYPE_FRIEND_CLASSES (type);
 364        classes;
 365        classes = TREE_CHAIN (classes))
 366     {
 367       tree probe = TREE_VALUE (classes);
 368
 369       if (TREE_CODE (friend_type) == TEMPLATE_DECL)
 370         {
 371           if (friend_type == probe)
 372             {
 373               if (complain)
 374                 warning (0, "%qD is already a friend of %qT", probe, type);
 375               break;
 376             }
 377         }
 378       else if (TREE_CODE (probe) != TEMPLATE_DECL)
 379         {
 380           if (same_type_p (probe, friend_type))
 381             {
 382               if (complain)
 383                 warning (0, "%qT is already a friend of %qT", probe, type);
 384               break;
 385             }
 386         }
 387     }
 388
 389   if (!classes)
 390     {
 391       maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1);
 392
 393       CLASSTYPE_FRIEND_CLASSES (type)
 394         = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
 395       if (TREE_CODE (friend_type) == TEMPLATE_DECL)
 396         friend_type = TREE_TYPE (friend_type);
 397       if (!uses_template_parms (type))
 398         CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
 399           = tree_cons (NULL_TREE, type,
 400                        CLASSTYPE_BEFRIENDING_CLASSES (friend_type));
 401     }
 402 }
 403
 404 /* Record DECL (a FUNCTION_DECL) as a friend of the
 405    CURRENT_CLASS_TYPE.  If DECL is a member function, CTYPE is the
 406    class of which it is a member, as named in the friend declaration.
 407    DECLARATOR is the name of the friend.  FUNCDEF_FLAG is true if the
 408    friend declaration is a definition of the function.  FLAGS is as
 409    for grokclass fn.  */
 410
 411 tree
 412 do_friend (tree ctype, tree declarator, tree decl,
 413            tree attrlist, enum overload_flags flags,
 414            bool funcdef_flag)
 415 {
 416   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 417   gcc_assert (!ctype || MAYBE_CLASS_TYPE_P (ctype));
 418
 419   /* Every decl that gets here is a friend of something.  */
 420   DECL_FRIEND_P (decl) = 1;
 421
 422   /* Unfortunately, we have to handle attributes here.  Normally we would
 423      handle them in start_decl_1, but since this is a friend decl start_decl_1
 424      never gets to see it.  */
 425
 426   /* Set attributes here so if duplicate decl, will have proper attributes.  */
 427   cplus_decl_attributes (&decl, attrlist, 0);
 428
 429   if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
 430     {
 431       declarator = TREE_OPERAND (declarator, 0);
 432       if (is_overloaded_fn (declarator))
 433         declarator = DECL_NAME (get_first_fn (declarator));
 434     }
 435
 436   if (ctype)
 437     {
 438       /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
 439          the enclosing class.  FRIEND_DEPTH counts the number of template
 440          headers used for this friend declaration.  TEMPLATE_MEMBER_P is
 441          true if a template header in FRIEND_DEPTH is intended for
 442          DECLARATOR.  For example, the code
 443
 444            template <class T> struct A {
 445              template <class U> struct B {
 446                template <class V> template <class W>
 447                  friend void C<V>::f(W);
 448              };
 449            };
 450
 451          will eventually give the following results
 452
 453          1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
 454          2. FRIEND_DEPTH equals 2 (for `V' and `W').
 455          3. TEMPLATE_MEMBER_P is true (for `W').  */
 456
 457       int class_template_depth = template_class_depth (current_class_type);
 458       int friend_depth = processing_template_decl - class_template_depth;
 459       /* We will figure this out later.  */
 460       bool template_member_p = false;
 461
 462       tree cname = TYPE_NAME (ctype);
 463       if (TREE_CODE (cname) == TYPE_DECL)
 464         cname = DECL_NAME (cname);
 465
 466       /* A method friend.  */
 467       if (flags == NO_SPECIAL && declarator == cname)
 468         DECL_CONSTRUCTOR_P (decl) = 1;
 469
 470       grokclassfn (ctype, decl, flags);
 471
 472       if (friend_depth)
 473         {
 474           if (!uses_template_parms_level (ctype, class_template_depth
 475                                                  + friend_depth))
 476             template_member_p = true;
 477         }
 478
 479       /* A nested class may declare a member of an enclosing class
 480          to be a friend, so we do lookup here even if CTYPE is in
 481          the process of being defined.  */
 482       if (class_template_depth
 483           || COMPLETE_TYPE_P (ctype)
 484           || (CLASS_TYPE_P (ctype) && TYPE_BEING_DEFINED (ctype)))
 485         {
 486           if (DECL_TEMPLATE_INFO (decl))
 487             /* DECL is a template specialization.  No need to
 488                build a new TEMPLATE_DECL.  */
 489             ;
 490           else if (class_template_depth)
 491             /* We rely on tsubst_friend_function to check the
 492                validity of the declaration later.  */
 493             decl = push_template_decl_real (decl, /*is_friend=*/true);
 494           else
 495             decl = check_classfn (ctype, decl,
 496                                   template_member_p
 497                                   ? current_template_parms
 498                                   : NULL_TREE);
 499
 500           if (template_member_p && decl && TREE_CODE (decl) == FUNCTION_DECL)
 501             decl = DECL_TI_TEMPLATE (decl);
 502
 503           if (decl)
 504             add_friend (current_class_type, decl, /*complain=*/true);
 505         }
 506       else
 507         error ("member %qD declared as friend before type %qT defined",
 508                   decl, ctype);
 509     }
 510   /* A global friend.
 511      @@ or possibly a friend from a base class ?!?  */
 512   else if (TREE_CODE (decl) == FUNCTION_DECL)
 513     {
 514       int is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P ();
 515
 516       /* Friends must all go through the overload machinery,
 517          even though they may not technically be overloaded.
 518
 519          Note that because classes all wind up being top-level
 520          in their scope, their friend wind up in top-level scope as well.  */
 521       if (funcdef_flag)
 522         SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
 523
 524       if (! DECL_USE_TEMPLATE (decl))
 525         {
 526           /* We must check whether the decl refers to template
 527              arguments before push_template_decl_real adds a
 528              reference to the containing template class.  */
 529           int warn = (warn_nontemplate_friend
 530                       && ! funcdef_flag && ! is_friend_template
 531                       && current_template_parms
 532                       && uses_template_parms (decl));
 533
 534           if (is_friend_template
 535               || template_class_depth (current_class_type) != 0)
 536             /* We can't call pushdecl for a template class, since in
 537                general, such a declaration depends on template
 538                parameters.  Instead, we call pushdecl when the class
 539                is instantiated.  */
 540             decl = push_template_decl_real (decl, /*is_friend=*/true);
 541           else if (current_function_decl)
 542             {
 543               /* This must be a local class.  11.5p11:
 544
 545                  If a friend declaration appears in a local class (9.8) and
 546                  the name specified is an unqualified name, a prior
 547                  declaration is looked up without considering scopes that
 548                  are outside the innermost enclosing non-class scope. For a
 549                  friend function declaration, if there is no prior
 550                  declaration, the program is ill-formed.  */
 551               tree t = lookup_name_innermost_nonclass_level (DECL_NAME (decl));
 552               if (t)
 553                 decl = pushdecl_maybe_friend (decl, /*is_friend=*/true);
 554               else
 555                 {
 556                   error ("friend declaration %qD in local class without "
 557                          "prior declaration", decl);
 558                   return error_mark_node;
 559                 }
 560             }
 561           else
 562             {
 563               /* We can't use pushdecl, as we might be in a template
 564                  class specialization, and pushdecl will insert an
 565                  unqualified friend decl into the template parameter
 566                  scope, rather than the namespace containing it.  */
 567               tree ns = decl_namespace_context (decl);
 568
 569               push_nested_namespace (ns);
 570               decl = pushdecl_namespace_level (decl, /*is_friend=*/true);
 571               pop_nested_namespace (ns);
 572             }
 573
 574           if (warn)
 575             {
 576               static int explained;
 577               bool warned;
 578
 579               warned = warning (OPT_Wnon_template_friend, "friend declaration "
 580                                 "%q#D declares a non-template function", decl);
 581               if (! explained && warned)
 582                 {
 583                   inform (input_location, "(if this is not what you intended, make sure "
 584                           "the function template has already been declared "
 585                           "and add <> after the function name here) ");
 586                   explained = 1;
 587                 }
 588             }
 589         }
 590
 591       if (decl == error_mark_node)
 592         return error_mark_node;
 593
 594       add_friend (current_class_type,
 595                   is_friend_template ? DECL_TI_TEMPLATE (decl) : decl,
 596                   /*complain=*/true);
 597       DECL_FRIEND_P (decl) = 1;
 598     }
 599
 600   return decl;
 601 }