void make_friend_class (tree type, tree friend_type, bool complain) { tree classes; /* CLASS_TEMPLATE_DEPTH counts the number of template headers for the enclosing class. FRIEND_DEPTH counts the number of template headers used for this friend declaration. TEMPLATE_MEMBER_P, defined inside the `if' block for TYPENAME_TYPE case, is true if a template header in FRIEND_DEPTH is intended for DECLARATOR. For example, the code template <class T> struct A { template <class U> struct B { template <class V> template <class W> friend class C<V>::D; }; }; will eventually give the following results 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U'). 2. FRIEND_DEPTH equals 2 (for `V' and `W'). 3. TEMPLATE_MEMBER_P is true (for `W'). The friend is a template friend iff FRIEND_DEPTH is nonzero. */ int class_template_depth = template_class_depth (type); int friend_depth = processing_template_decl - class_template_depth; if (! MAYBE_CLASS_TYPE_P (friend_type)) { error ("invalid type %qT declared %<friend%>", friend_type); return; } if (friend_depth) /* If the TYPE is a template then it makes sense for it to be friends with itself; this means that each instantiation is friends with all other instantiations. */ { if (CLASS_TYPE_P (friend_type) && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type) && uses_template_parms (friend_type)) { /* [temp.friend] Friend declarations shall not declare partial specializations. */ error ("partial specialization %qT declared %<friend%>", friend_type); return; } } else if (same_type_p (type, friend_type)) { if (complain) warning (0, "class %qT is implicitly friends with itself", type); return; } /* [temp.friend] A friend of a class or class template can be a function or class template, a specialization of a function template or class template, or an ordinary (nontemplate) function or class. */ if (!friend_depth) ;/* ok */ else if (TREE_CODE (friend_type) == TYPENAME_TYPE) { if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type)) == TEMPLATE_ID_EXPR) { /* template <class U> friend class T::X<U>; */ /* [temp.friend] Friend declarations shall not declare partial specializations. */ error ("partial specialization %qT declared %<friend%>", friend_type); return; } else { /* We will figure this out later. */ bool template_member_p = false; tree ctype = TYPE_CONTEXT (friend_type); tree name = TYPE_IDENTIFIER (friend_type); tree decl; if (!uses_template_parms_level (ctype, class_template_depth + friend_depth)) template_member_p = true; if (class_template_depth) { /* We rely on tsubst_friend_class to check the validity of the declaration later. */ if (template_member_p) friend_type = make_unbound_class_template (ctype, name, current_template_parms, tf_error); else friend_type = make_typename_type (ctype, name, class_type, tf_error); } else { decl = lookup_member (ctype, name, 0, true); if (!decl) { error ("%qT is not a member of %qT", name, ctype); return; } if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl)) { error ("%qT is not a member class template of %qT", name, ctype); error ("%q+D declared here", decl); return; } if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL || !CLASS_TYPE_P (TREE_TYPE (decl)))) { error ("%qT is not a nested class of %qT", name, ctype); error ("%q+D declared here", decl); return; } friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)); } } } else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM) { /* template <class T> friend class T; */ error ("template parameter type %qT declared %<friend%>", friend_type); return; } else if (!CLASSTYPE_TEMPLATE_INFO (friend_type)) { /* template <class T> friend class A; where A is not a template */ error ("%q#T is not a template", friend_type); return; } else /* template <class T> friend class A; where A is a template */ friend_type = CLASSTYPE_TI_TEMPLATE (friend_type); if (friend_type == error_mark_node) return; /* See if it is already a friend. */ for (classes = CLASSTYPE_FRIEND_CLASSES (type); classes; classes = TREE_CHAIN (classes)) { tree probe = TREE_VALUE (classes); if (TREE_CODE (friend_type) == TEMPLATE_DECL) { if (friend_type == probe) { if (complain) warning (0, "%qD is already a friend of %qT", probe, type); break; } } else if (TREE_CODE (probe) != TEMPLATE_DECL) { if (same_type_p (probe, friend_type)) { if (complain) warning (0, "%qT is already a friend of %qT", probe, type); break; } } } if (!classes) { maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1); CLASSTYPE_FRIEND_CLASSES (type) = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type)); if (TREE_CODE (friend_type) == TEMPLATE_DECL) friend_type = TREE_TYPE (friend_type); if (!uses_template_parms (type)) CLASSTYPE_BEFRIENDING_CLASSES (friend_type) = tree_cons (NULL_TREE, type, CLASSTYPE_BEFRIENDING_CLASSES (friend_type)); } }
tree do_friend (tree ctype, tree declarator, tree decl, tree attrlist, enum overload_flags flags, bool funcdef_flag) { gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); gcc_assert (!ctype || MAYBE_CLASS_TYPE_P (ctype)); /* Every decl that gets here is a friend of something. */ DECL_FRIEND_P (decl) = 1; /* Unfortunately, we have to handle attributes here. Normally we would handle them in start_decl_1, but since this is a friend decl start_decl_1 never gets to see it. */ /* Set attributes here so if duplicate decl, will have proper attributes. */ cplus_decl_attributes (&decl, attrlist, 0); if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) { declarator = TREE_OPERAND (declarator, 0); if (is_overloaded_fn (declarator)) declarator = DECL_NAME (get_first_fn (declarator)); } if (ctype) { /* CLASS_TEMPLATE_DEPTH counts the number of template headers for the enclosing class. FRIEND_DEPTH counts the number of template headers used for this friend declaration. TEMPLATE_MEMBER_P is true if a template header in FRIEND_DEPTH is intended for DECLARATOR. For example, the code template <class T> struct A { template <class U> struct B { template <class V> template <class W> friend void C<V>::f(W); }; }; will eventually give the following results 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U'). 2. FRIEND_DEPTH equals 2 (for `V' and `W'). 3. TEMPLATE_MEMBER_P is true (for `W'). */ int class_template_depth = template_class_depth (current_class_type); int friend_depth = processing_template_decl - class_template_depth; /* We will figure this out later. */ bool template_member_p = false; tree cname = TYPE_NAME (ctype); if (TREE_CODE (cname) == TYPE_DECL) cname = DECL_NAME (cname); /* A method friend. */ if (flags == NO_SPECIAL && declarator == cname) DECL_CONSTRUCTOR_P (decl) = 1; grokclassfn (ctype, decl, flags); if (friend_depth) { if (!uses_template_parms_level (ctype, class_template_depth + friend_depth)) template_member_p = true; } /* A nested class may declare a member of an enclosing class to be a friend, so we do lookup here even if CTYPE is in the process of being defined. */ if (class_template_depth || COMPLETE_TYPE_P (ctype) || (CLASS_TYPE_P (ctype) && TYPE_BEING_DEFINED (ctype))) { if (DECL_TEMPLATE_INFO (decl)) /* DECL is a template specialization. No need to build a new TEMPLATE_DECL. */ ; else if (class_template_depth) /* We rely on tsubst_friend_function to check the validity of the declaration later. */ decl = push_template_decl_real (decl, /*is_friend=*/true); else decl = check_classfn (ctype, decl, template_member_p ? current_template_parms : NULL_TREE); if (template_member_p && decl && TREE_CODE (decl) == FUNCTION_DECL) decl = DECL_TI_TEMPLATE (decl); if (decl) add_friend (current_class_type, decl, /*complain=*/true); } else error ("member %qD declared as friend before type %qT defined", decl, ctype); } /* A global friend. @@ or possibly a friend from a base class ?!? */ else if (TREE_CODE (decl) == FUNCTION_DECL) { int is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P (); /* Friends must all go through the overload machinery, even though they may not technically be overloaded. Note that because classes all wind up being top-level in their scope, their friend wind up in top-level scope as well. */ if (funcdef_flag) SET_DECL_FRIEND_CONTEXT (decl, current_class_type); if (! DECL_USE_TEMPLATE (decl)) { /* We must check whether the decl refers to template arguments before push_template_decl_real adds a reference to the containing template class. */ int warn = (warn_nontemplate_friend && ! funcdef_flag && ! is_friend_template && current_template_parms && uses_template_parms (decl)); if (is_friend_template || template_class_depth (current_class_type) != 0) /* We can't call pushdecl for a template class, since in general, such a declaration depends on template parameters. Instead, we call pushdecl when the class is instantiated. */ decl = push_template_decl_real (decl, /*is_friend=*/true); else if (current_function_decl) { /* This must be a local class. 11.5p11: If a friend declaration appears in a local class (9.8) and the name specified is an unqualified name, a prior declaration is looked up without considering scopes that are outside the innermost enclosing non-class scope. For a friend function declaration, if there is no prior declaration, the program is ill-formed. */ tree t = lookup_name_innermost_nonclass_level (DECL_NAME (decl)); if (t) decl = pushdecl_maybe_friend (decl, /*is_friend=*/true); else { error ("friend declaration %qD in local class without " "prior declaration", decl); return error_mark_node; } } else { /* We can't use pushdecl, as we might be in a template class specialization, and pushdecl will insert an unqualified friend decl into the template parameter scope, rather than the namespace containing it. */ tree ns = decl_namespace_context (decl); push_nested_namespace (ns); decl = pushdecl_namespace_level (decl, /*is_friend=*/true); pop_nested_namespace (ns); } if (warn) { static int explained; bool warned; warned = warning (OPT_Wnon_template_friend, "friend declaration " "%q#D declares a non-template function", decl); if (! explained && warned) { inform (input_location, "(if this is not what you intended, make sure " "the function template has already been declared " "and add <> after the function name here) "); explained = 1; } } } if (decl == error_mark_node) return error_mark_node; add_friend (current_class_type, is_friend_template ? DECL_TI_TEMPLATE (decl) : decl, /*complain=*/true); DECL_FRIEND_P (decl) = 1; } return decl; }
void make_friend_class (tree type, tree friend_type, bool complain) { tree classes; /* CLASS_TEMPLATE_DEPTH counts the number of template headers for the enclosing class. FRIEND_DEPTH counts the number of template headers used for this friend declaration. TEMPLATE_MEMBER_P, defined inside the `if' block for TYPENAME_TYPE case, is true if a template header in FRIEND_DEPTH is intended for DECLARATOR. For example, the code template <class T> struct A { template <class U> struct B { template <class V> template <class W> friend class C<V>::D; }; }; will eventually give the following results 1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U'). 2. FRIEND_DEPTH equals 2 (for `V' and `W'). 3. TEMPLATE_MEMBER_P is true (for `W'). The friend is a template friend iff FRIEND_DEPTH is nonzero. */ int class_template_depth = template_class_depth (type); int friend_depth = processing_template_decl - class_template_depth; if (! MAYBE_CLASS_TYPE_P (friend_type) && TREE_CODE (friend_type) != TEMPLATE_TEMPLATE_PARM) { /* N1791: If the type specifier in a friend declaration designates a (possibly cv-qualified) class type, that class is declared as a friend; otherwise, the friend declaration is ignored. So don't complain in C++11 mode. */ if (cxx_dialect < cxx11) pedwarn (input_location, complain ? 0 : OPT_Wpedantic, "invalid type %qT declared %<friend%>", friend_type); return; } friend_type = cv_unqualified (friend_type); if (check_for_bare_parameter_packs (friend_type)) return; if (friend_depth) { /* [temp.friend] Friend declarations shall not declare partial specializations. */ if (CLASS_TYPE_P (friend_type) && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type) && uses_template_parms (friend_type)) { error ("partial specialization %qT declared %<friend%>", friend_type); return; } if (TYPE_TEMPLATE_INFO (friend_type) && !PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (friend_type))) { error ("%qT is not a template", friend_type); inform (location_of (friend_type), "previous declaration here"); if (TYPE_CLASS_SCOPE_P (friend_type) && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (friend_type)) && currently_open_class (TYPE_CONTEXT (friend_type))) inform (input_location, "perhaps you need explicit template " "arguments in your nested-name-specifier"); return; } } /* It makes sense for a template class to be friends with itself, that means the instantiations can be friendly. Other cases are not so meaningful. */ if (!friend_depth && same_type_p (type, friend_type)) { if (complain) warning (0, "class %qT is implicitly friends with itself", type); return; } /* [temp.friend] A friend of a class or class template can be a function or class template, a specialization of a function template or class template, or an ordinary (nontemplate) function or class. */ if (!friend_depth) ;/* ok */ else if (TREE_CODE (friend_type) == TYPENAME_TYPE) { if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type)) == TEMPLATE_ID_EXPR) { /* template <class U> friend class T::X<U>; */ /* [temp.friend] Friend declarations shall not declare partial specializations. */ error ("partial specialization %qT declared %<friend%>", friend_type); return; } else { /* We will figure this out later. */ bool template_member_p = false; tree ctype = TYPE_CONTEXT (friend_type); tree name = TYPE_IDENTIFIER (friend_type); tree decl; if (!uses_template_parms_level (ctype, class_template_depth + friend_depth)) template_member_p = true; if (class_template_depth) { /* We rely on tsubst_friend_class to check the validity of the declaration later. */ if (template_member_p) friend_type = make_unbound_class_template (ctype, name, current_template_parms, tf_error); else friend_type = make_typename_type (ctype, name, class_type, tf_error); } else { decl = lookup_member (ctype, name, 0, true, tf_warning_or_error); if (!decl) { error ("%qT is not a member of %qT", name, ctype); return; } if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl)) { error ("%qT is not a member class template of %qT", name, ctype); inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl); return; } if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL || !CLASS_TYPE_P (TREE_TYPE (decl)))) { error ("%qT is not a nested class of %qT", name, ctype); inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl); return; } friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)); } } } else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM) { /* template <class T> friend class T; */ error ("template parameter type %qT declared %<friend%>", friend_type); return; } else if (TREE_CODE (friend_type) == TEMPLATE_TEMPLATE_PARM) friend_type = TYPE_NAME (friend_type); else if (!CLASSTYPE_TEMPLATE_INFO (friend_type)) { /* template <class T> friend class A; where A is not a template */ error ("%q#T is not a template", friend_type); return; } else /* template <class T> friend class A; where A is a template */ friend_type = CLASSTYPE_TI_TEMPLATE (friend_type); if (friend_type == error_mark_node) return; /* See if it is already a friend. */ for (classes = CLASSTYPE_FRIEND_CLASSES (type); classes; classes = TREE_CHAIN (classes)) { tree probe = TREE_VALUE (classes); if (TREE_CODE (friend_type) == TEMPLATE_DECL) { if (friend_type == probe) { if (complain) warning (OPT_Wredundant_decls, "%qD is already a friend of %qT", probe, type); break; } } else if (TREE_CODE (probe) != TEMPLATE_DECL) { if (same_type_p (probe, friend_type)) { if (complain) warning (OPT_Wredundant_decls, "%qT is already a friend of %qT", probe, type); break; } } } if (!classes) { maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1); CLASSTYPE_FRIEND_CLASSES (type) = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type)); if (TREE_CODE (friend_type) == TEMPLATE_DECL) friend_type = TREE_TYPE (friend_type); if (!uses_template_parms (type)) CLASSTYPE_BEFRIENDING_CLASSES (friend_type) = tree_cons (NULL_TREE, type, CLASSTYPE_BEFRIENDING_CLASSES (friend_type)); } }