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                   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       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       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       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       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       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       error ("`%#T' is not a template", friend_type);
 252       return;
 253     }
 254
 255   if (is_template_friend)
 256     friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
 257
 258   classes = CLASSTYPE_FRIEND_CLASSES (type);
 259   while (classes
 260          /* Stop if we find the same type on the list.  */
 261          && !(TREE_CODE (TREE_VALUE (classes)) == TEMPLATE_DECL ?
 262               friend_type == TREE_VALUE (classes) :
 263               same_type_p (TREE_VALUE (classes), friend_type)))
 264     classes = TREE_CHAIN (classes);
 265   if (classes)
 266     warning ("`%T' is already a friend of `%T'",
 267                 TREE_VALUE (classes), type);
 268   else
 269     {
 270       CLASSTYPE_FRIEND_CLASSES (type)
 271         = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
 272       if (is_template_friend)
 273         friend_type = TREE_TYPE (friend_type);
 274       if (!uses_template_parms (type))
 275         CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
 276           = tree_cons (NULL_TREE, type,
 277                        CLASSTYPE_BEFRIENDING_CLASSES (friend_type));
 278     }
 279 }
 280
 281 /* Main friend processor.  This is large, and for modularity purposes,
 282    has been removed from grokdeclarator.  It returns `void_type_node'
 283    to indicate that something happened, though a FIELD_DECL is
 284    not returned.
 285
 286    CTYPE is the class this friend belongs to.
 287
 288    DECLARATOR is the name of the friend.
 289
 290    DECL is the FUNCTION_DECL that the friend is.
 291
 292    In case we are parsing a friend which is part of an inline
 293    definition, we will need to store PARM_DECL chain that comes
 294    with it into the DECL_ARGUMENTS slot of the FUNCTION_DECL.
 295
 296    FLAGS is just used for `grokclassfn'.
 297
 298    QUALS say what special qualifies should apply to the object
 299    pointed to by `this'.  */
 300
 301 tree
 302 do_friend (ctype, declarator, decl, parmdecls, attrlist,
 303            flags, quals, funcdef_flag)
 304      tree ctype, declarator, decl, parmdecls, attrlist;
 305      enum overload_flags flags;
 306      tree quals;
 307      int funcdef_flag;
 308 {
 309   int is_friend_template = 0;
 310
 311   /* Every decl that gets here is a friend of something.  */
 312   DECL_FRIEND_P (decl) = 1;
 313
 314   if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
 315     {
 316       declarator = TREE_OPERAND (declarator, 0);
 317       if (TREE_CODE (declarator) == LOOKUP_EXPR)
 318         declarator = TREE_OPERAND (declarator, 0);
 319       if (is_overloaded_fn (declarator))
 320         declarator = DECL_NAME (get_first_fn (declarator));
 321     }
 322
 323   if (TREE_CODE (decl) != FUNCTION_DECL)
 324     abort ();
 325
 326   is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P ();
 327
 328   if (ctype)
 329     {
 330       tree cname = TYPE_NAME (ctype);
 331       if (TREE_CODE (cname) == TYPE_DECL)
 332         cname = DECL_NAME (cname);
 333
 334       /* A method friend.  */
 335       if (flags == NO_SPECIAL && ctype && declarator == cname)
 336         DECL_CONSTRUCTOR_P (decl) = 1;
 337
 338       /* This will set up DECL_ARGUMENTS for us.  */
 339       grokclassfn (ctype, decl, flags, quals);
 340
 341       if (is_friend_template)
 342         decl = DECL_TI_TEMPLATE (push_template_decl (decl));
 343       else if (template_class_depth (current_class_type))
 344         decl = push_template_decl_real (decl, /*is_friend=*/1);
 345
 346       /* We can't do lookup in a type that involves template
 347          parameters.  Instead, we rely on tsubst_friend_function
 348          to check the validity of the declaration later.  */
 349       if (processing_template_decl)
 350         add_friend (current_class_type, decl);
 351       /* A nested class may declare a member of an enclosing class
 352          to be a friend, so we do lookup here even if CTYPE is in
 353          the process of being defined.  */
 354       else if (COMPLETE_TYPE_P (ctype) || TYPE_BEING_DEFINED (ctype))
 355         {
 356           decl = check_classfn (ctype, decl);
 357
 358           if (decl)
 359             add_friend (current_class_type, decl);
 360         }
 361       else
 362         error ("member `%D' declared as friend before type `%T' defined",
 363                   decl, ctype);
 364     }
 365   /* A global friend.
 366      @@ or possibly a friend from a base class ?!?  */
 367   else if (TREE_CODE (decl) == FUNCTION_DECL)
 368     {
 369       /* Friends must all go through the overload machinery,
 370          even though they may not technically be overloaded.
 371
 372          Note that because classes all wind up being top-level
 373          in their scope, their friend wind up in top-level scope as well.  */
 374       DECL_ARGUMENTS (decl) = parmdecls;
 375       if (funcdef_flag)
 376         SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
 377
 378       if (! DECL_USE_TEMPLATE (decl))
 379         {
 380           /* We must check whether the decl refers to template
 381              arguments before push_template_decl_real adds a
 382              reference to the containing template class.  */
 383           int warn = (warn_nontemplate_friend
 384                       && ! funcdef_flag && ! is_friend_template
 385                       && current_template_parms
 386                       && uses_template_parms (decl));
 387
 388           if (is_friend_template
 389               || template_class_depth (current_class_type) != 0)
 390             /* We can't call pushdecl for a template class, since in
 391                general, such a declaration depends on template
 392                parameters.  Instead, we call pushdecl when the class
 393                is instantiated.  */
 394             decl = push_template_decl_real (decl, /*is_friend=*/1);
 395           else if (current_function_decl)
 396             /* This must be a local class, so pushdecl will be ok, and
 397                insert an unqualified friend into the local scope
 398                (rather than the containing namespace scope, which the
 399                next choice will do). */
 400             decl = pushdecl (decl);
 401           else
 402             {
 403               /* We can't use pushdecl, as we might be in a template
 404                  class specialization, and pushdecl will insert an
 405                  unqualified friend decl into the template parameter
 406                  scope, rather than the namespace containing it. */
 407               tree ns = decl_namespace_context (decl);
 408
 409               push_nested_namespace (ns);
 410               decl = pushdecl_namespace_level (decl);
 411               pop_nested_namespace (ns);
 412             }
 413
 414           if (warn)
 415             {
 416               static int explained;
 417               warning ("friend declaration `%#D' declares a non-template function", decl);
 418               if (! explained)
 419                 {
 420                   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");
 421                   explained = 1;
 422                 }
 423             }
 424         }
 425
 426       add_friend (current_class_type,
 427                   is_friend_template ? DECL_TI_TEMPLATE (decl) : decl);
 428       DECL_FRIEND_P (decl) = 1;
 429     }
 430
 431   /* Unfortunately, we have to handle attributes here.  Normally we would
 432      handle them in start_decl_1, but since this is a friend decl start_decl_1
 433      never gets to see it.  */
 434
 435   /* Set attributes here so if duplicate decl, will have proper attributes.  */
 436   cplus_decl_attributes (&decl, attrlist, 0);
 437
 438   return decl;
 439 }