gcc/cp/friend.c

   1 /* Help friends in C++.
   2    Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC 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 2, or (at your option)
   9 any later version.
  10
  11 GNU CC 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 GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "tree.h"
  24 #include "rtl.h"
  25 #include "expr.h"
  26 #include "cp-tree.h"
  27 #include "flags.h"
  28 #include "output.h"
  29 #include "toplev.h"
  30
  31 /* Friend data structures are described in cp-tree.h.  */
  32
  33 /* Returns non-zero if SUPPLICANT is a friend of TYPE.  */
  34
  35 int
  36 is_friend (type, supplicant)
  37      tree type, supplicant;
  38 {
  39   int declp;
  40   register tree list;
  41   tree context;
  42
  43   if (supplicant == NULL_TREE || type == NULL_TREE)
  44     return 0;
  45
  46   declp = DECL_P (supplicant);
  47
  48   if (declp)
  49     /* It's a function decl.  */
  50     {
  51       tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
  52       tree name = DECL_NAME (supplicant);
  53
  54       for (; list ; list = TREE_CHAIN (list))
  55         {
  56           if (name == FRIEND_NAME (list))
  57             {
  58               tree friends = FRIEND_DECLS (list);
  59               for (; friends ; friends = TREE_CHAIN (friends))
  60                 {
  61                   if (TREE_VALUE (friends) == NULL_TREE)
  62                     continue;
  63
  64                   if (supplicant == TREE_VALUE (friends))
  65                     return 1;
  66
  67                   /* Temporarily, we are more lenient to deal with
  68                      nested friend functions, for which there can be
  69                      more than one FUNCTION_DECL, despite being the
  70                      same function.  When that's fixed, this bit can
  71                      go.  */
  72                   if (DECL_FUNCTION_MEMBER_P (supplicant)
  73                       && same_type_p (TREE_TYPE (supplicant),
  74                                       TREE_TYPE (TREE_VALUE (friends))))
  75                     return 1;
  76
  77                   if (TREE_CODE (TREE_VALUE (friends)) == TEMPLATE_DECL
  78                       && is_specialization_of (supplicant,
  79                                                TREE_VALUE (friends)))
  80                     return 1;
  81                 }
  82               break;
  83             }
  84         }
  85     }
  86   else
  87     /* It's a type.  */
  88     {
  89       /* Nested classes are implicitly friends of their enclosing types, as
  90          per core issue 45 (this is a change from the standard).  */
  91       for (context = supplicant;
  92            context && TYPE_P (context);
  93            context = TYPE_CONTEXT (context))
  94         if (type == context)
  95           return 1;
  96
  97       list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type)));
  98       for (; list ; list = TREE_CHAIN (list))
  99         {
 100           tree t = TREE_VALUE (list);
 101
 102           if (TREE_CODE (t) == TEMPLATE_DECL ?
 103               is_specialization_of (TYPE_MAIN_DECL (supplicant), t) :
 104               same_type_p (supplicant, t))
 105             return 1;
 106         }
 107     }
 108
 109   if (declp && DECL_FUNCTION_MEMBER_P (supplicant))
 110     context = DECL_CONTEXT (supplicant);
 111   else if (! declp)
 112     /* Local classes have the same access as the enclosing function.  */
 113     context = decl_function_context (TYPE_MAIN_DECL (supplicant));
 114   else
 115     context = NULL_TREE;
 116
 117   /* A namespace is not friend to anybody. */
 118   if (context && TREE_CODE (context) == NAMESPACE_DECL)
 119     context = NULL_TREE;
 120
 121   if (context)
 122     return is_friend (type, context);
 123
 124   return 0;
 125 }
 126
 127 /* Add a new friend to the friends of the aggregate type TYPE.
 128    DECL is the FUNCTION_DECL of the friend being added.  */
 129
 130 void
 131 add_friend (type, decl)
 132      tree type, decl;
 133 {
 134   tree typedecl;
 135   tree list;
 136   tree name;
 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                   cp_warning ("`%D' is already a friend of class `%T'",
 156                               decl, type);
 157                   cp_warning_at ("previous friend declaration of `%D'",
 158                                  TREE_VALUE (friends));
 159                   return;
 160                 }
 161             }
 162           TREE_VALUE (list) = tree_cons (error_mark_node, decl,
 163                                          TREE_VALUE (list));
 164           return;
 165         }
 166       list = TREE_CHAIN (list);
 167     }
 168
 169   DECL_FRIENDLIST (typedecl)
 170     = tree_cons (DECL_NAME (decl), build_tree_list (error_mark_node, decl),
 171                  DECL_FRIENDLIST (typedecl));
 172   if (!uses_template_parms (type))
 173     DECL_BEFRIENDING_CLASSES (decl)
 174       = tree_cons (NULL_TREE, type,
 175                    DECL_BEFRIENDING_CLASSES (decl));
 176 }
 177
 178 /* Make FRIEND_TYPE a friend class to TYPE.  If FRIEND_TYPE has already
 179    been defined, we make all of its member functions friends of
 180    TYPE.  If not, we make it a pending friend, which can later be added
 181    when its definition is seen.  If a type is defined, then its TYPE_DECL's
 182    DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
 183    classes that are not defined.  If a type has not yet been defined,
 184    then the DECL_WAITING_FRIENDS contains a list of types
 185    waiting to make it their friend.  Note that these two can both
 186    be in use at the same time!  */
 187
 188 void
 189 make_friend_class (type, friend_type)
 190      tree type, friend_type;
 191 {
 192   tree classes;
 193   int is_template_friend;
 194
 195   if (! IS_AGGR_TYPE (friend_type))
 196     {
 197       cp_error ("invalid type `%T' declared `friend'", friend_type);
 198       return;
 199     }
 200
 201   if (CLASS_TYPE_P (friend_type)
 202       && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type)
 203       && uses_template_parms (friend_type))
 204     {
 205       /* [temp.friend]
 206
 207          Friend declarations shall not declare partial
 208          specializations.  */
 209       cp_error ("partial specialization `%T' declared `friend'",
 210                 friend_type);
 211       return;
 212     }
 213
 214   if (processing_template_decl > template_class_depth (type))
 215     /* If the TYPE is a template then it makes sense for it to be
 216        friends with itself; this means that each instantiation is
 217        friends with all other instantiations.  */
 218     is_template_friend = 1;
 219   else if (same_type_p (type, friend_type))
 220     {
 221       cp_pedwarn ("class `%T' is implicitly friends with itself",
 222                   type);
 223       return;
 224     }
 225   else
 226     is_template_friend = 0;
 227
 228   /* [temp.friend]
 229
 230      A friend of a class or class template can be a function or
 231      class template, a specialization of a function template or
 232      class template, or an ordinary (nontemplate) function or
 233      class. */
 234   if (!is_template_friend)
 235     ;/* ok */
 236   else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
 237     {
 238       /* template <class T> friend typename S<T>::X; */
 239       cp_error ("typename type `%#T' declared `friend'", friend_type);
 240       return;
 241     }
 242   else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
 243     {
 244       /* template <class T> friend class T; */
 245       cp_error ("template parameter type `%T' declared `friend'", friend_type);
 246       return;
 247     }
 248   else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
 249     {
 250       /* template <class T> friend class A; where A is not a template */
 251       cp_error ("`%#T' is not a template", friend_type);
 252       return;
 253     }
 254
 255   GNU_xref_hier (type, friend_type, 0, 0, 1);
 256
 257   if (is_template_friend)
 258     friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
 259
 260   classes = CLASSTYPE_FRIEND_CLASSES (type);
 261   while (classes
 262          /* Stop if we find the same type on the list.  */
 263          && !(TREE_CODE (TREE_VALUE (classes)) == TEMPLATE_DECL ?
 264               friend_type == TREE_VALUE (classes) :
 265               same_type_p (TREE_VALUE (classes), friend_type)))
 266     classes = TREE_CHAIN (classes);
 267   if (classes)
 268     cp_warning ("`%T' is already a friend of `%T'",
 269                 TREE_VALUE (classes), type);
 270   else
 271     {
 272       CLASSTYPE_FRIEND_CLASSES (type)
 273         = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
 274       if (is_template_friend)
 275         friend_type = TREE_TYPE (friend_type);
 276       if (!uses_template_parms (type))
 277         CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
 278           = tree_cons (NULL_TREE, type,
 279                        CLASSTYPE_BEFRIENDING_CLASSES (friend_type));
 280     }
 281 }
 282
 283 /* Main friend processor.  This is large, and for modularity purposes,
 284    has been removed from grokdeclarator.  It returns `void_type_node'
 285    to indicate that something happened, though a FIELD_DECL is
 286    not returned.
 287
 288    CTYPE is the class this friend belongs to.
 289
 290    DECLARATOR is the name of the friend.
 291
 292    DECL is the FUNCTION_DECL that the friend is.
 293
 294    In case we are parsing a friend which is part of an inline
 295    definition, we will need to store PARM_DECL chain that comes
 296    with it into the DECL_ARGUMENTS slot of the FUNCTION_DECL.
 297
 298    FLAGS is just used for `grokclassfn'.
 299
 300    QUALS say what special qualifies should apply to the object
 301    pointed to by `this'.  */
 302
 303 tree
 304 do_friend (ctype, declarator, decl, parmdecls, attrlist,
 305            flags, quals, funcdef_flag)
 306      tree ctype, declarator, decl, parmdecls, attrlist;
 307      enum overload_flags flags;
 308      tree quals;
 309      int funcdef_flag;
 310 {
 311   int is_friend_template = 0;
 312   tree prefix_attributes, attributes;
 313
 314   /* Every decl that gets here is a friend of something.  */
 315   DECL_FRIEND_P (decl) = 1;
 316
 317   if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
 318     {
 319       declarator = TREE_OPERAND (declarator, 0);
 320       if (TREE_CODE (declarator) == LOOKUP_EXPR)
 321         declarator = TREE_OPERAND (declarator, 0);
 322       if (is_overloaded_fn (declarator))
 323         declarator = DECL_NAME (get_first_fn (declarator));
 324     }
 325
 326   if (TREE_CODE (decl) != FUNCTION_DECL)
 327     my_friendly_abort (990513);
 328
 329   is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P ();
 330
 331   if (ctype)
 332     {
 333       tree cname = TYPE_NAME (ctype);
 334       if (TREE_CODE (cname) == TYPE_DECL)
 335         cname = DECL_NAME (cname);
 336
 337       /* A method friend.  */
 338       if (flags == NO_SPECIAL && ctype && declarator == cname)
 339         DECL_CONSTRUCTOR_P (decl) = 1;
 340
 341       /* This will set up DECL_ARGUMENTS for us.  */
 342       grokclassfn (ctype, decl, flags, quals);
 343
 344       if (is_friend_template)
 345         decl = DECL_TI_TEMPLATE (push_template_decl (decl));
 346       else if (template_class_depth (current_class_type))
 347         decl = push_template_decl_real (decl, /*is_friend=*/1);
 348
 349       /* We can't do lookup in a type that involves template
 350          parameters.  Instead, we rely on tsubst_friend_function
 351          to check the validity of the declaration later.  */
 352       if (processing_template_decl)
 353         add_friend (current_class_type, decl);
 354       /* A nested class may declare a member of an enclosing class
 355          to be a friend, so we do lookup here even if CTYPE is in
 356          the process of being defined.  */
 357       else if (COMPLETE_TYPE_P (ctype) || TYPE_BEING_DEFINED (ctype))
 358         {
 359           decl = check_classfn (ctype, decl);
 360
 361           if (decl)
 362             add_friend (current_class_type, decl);
 363         }
 364       else
 365         cp_error ("member `%D' declared as friend before type `%T' defined",
 366                   decl, ctype);
 367     }
 368   /* A global friend.
 369      @@ or possibly a friend from a base class ?!?  */
 370   else if (TREE_CODE (decl) == FUNCTION_DECL)
 371     {
 372       /* Friends must all go through the overload machinery,
 373          even though they may not technically be overloaded.
 374
 375          Note that because classes all wind up being top-level
 376          in their scope, their friend wind up in top-level scope as well.  */
 377       DECL_ARGUMENTS (decl) = parmdecls;
 378       if (funcdef_flag)
 379         SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
 380
 381       if (! DECL_USE_TEMPLATE (decl))
 382         {
 383           /* We must check whether the decl refers to template
 384              arguments before push_template_decl_real adds a
 385              reference to the containing template class.  */
 386           int warn = (warn_nontemplate_friend
 387                       && ! funcdef_flag && ! is_friend_template
 388                       && current_template_parms
 389                       && uses_template_parms (decl));
 390
 391           /* We can call pushdecl here, because the TREE_CHAIN of this
 392              FUNCTION_DECL is not needed for other purposes.  Don't do
 393              this for a template instantiation.  However, we don't
 394              call pushdecl() for a friend function of a template
 395              class, since in general, such a declaration depends on
 396              template parameters.  Instead, we call pushdecl when the
 397              class is instantiated.  */
 398           if (!is_friend_template
 399               && template_class_depth (current_class_type) == 0)
 400             decl = pushdecl (decl);
 401           else
 402             decl = push_template_decl_real (decl, /*is_friend=*/1);
 403
 404           if (warn)
 405             {
 406               static int explained;
 407               cp_warning ("friend declaration `%#D' declares a non-template function", decl);
 408               if (! explained)
 409                 {
 410                   warning ("(if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning.");
 411                   explained = 1;
 412                 }
 413             }
 414         }
 415
 416       make_decl_rtl (decl, NULL_PTR);
 417       add_friend (current_class_type,
 418                   is_friend_template ? DECL_TI_TEMPLATE (decl) : decl);
 419       DECL_FRIEND_P (decl) = 1;
 420     }
 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   if (attrlist)
 427     {
 428       attributes = TREE_PURPOSE (attrlist);
 429       prefix_attributes = TREE_VALUE (attrlist);
 430     }
 431   else
 432     {
 433       attributes = NULL_TREE;
 434       prefix_attributes = NULL_TREE;
 435     }
 436
 437 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
 438   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
 439 #endif
 440
 441   /* Set attributes here so if duplicate decl, will have proper attributes.  */
 442   cplus_decl_attributes (decl, attributes, prefix_attributes);
 443
 444   return decl;
 445 }