Warn if friend function depends on template parameters.

[sepavloff]

Summary

Declaration of friend function may depend on template parameters,
however it does not become a template function:

template<typename T> class C1 {
  friend void func(T x);
};

It may be not obvious for user, so compiler could emit a warning in
such case. This patch implements appropriate warning, similar to GCC
warning -Wnon-template-friend. The warning is not issued if translation
unit contains a function declaration in appropriate namespace that
can redeclare the friend function in some class instantiation.
For the example above it could be a declaration:

void func(int x);

This change fixes PR23342.

[sepavloff]

Any feedback?

Thanks,
--Serge

[sepavloff]

Could someone provide a feedback?

Thanks,
--Serge

[sepavloff]

Ping.

Thanks,
--Serge

[sepavloff]

Do not emit warning on class methods.

[rsmith]

It seems useful to warn on this, but I'm concerned that there are valid code patterns that this will warn about where there is no reasonable way to rewrite the code that would suppress the warning. For instance:

template<typename T> class X {
  friend void process(X<T>);
  // ...
};
void process(X<int>) { /* ... */ }
void process(X<char>) ( /* ... */ }

As an alternative, can we suppress the warning until we see an "almost matching" template declaration in the surrounding scope? For instance:

template<typename T> void process(X<T>) { /* ... */ } // warning, not a friend of X<T>

include/clang/Basic/DiagnosticSemaKinds.td

1276–1278

Maybe just: "to befriend a template specialization, use <>", along with a FixItHint showing where to add the <>.

It would also seem like a good idea to check if there is such a function template declared, and give different diagnostic if not.

[sepavloff]

Updated patch

Added a check for presence of template declaration corresponding to the friend
function. Presence of similar functions but with specializations as argument
types is also checked now.

Made an atempt to make messages more clear to end user, not sure however if
they become better.

[sepavloff]

Changed implementation of friend function set.

Friend functions declared in template classes are not added to redeclaration chains,
but access to them is needed to make some checks. This change allows using the
set of friend functions not only to emit particular warning but also to serve as a
registry of file-level friend functions.

[rsmith]

include/clang/Basic/DiagnosticSemaKinds.td

1275

template function -> function template

1277–1279

Rather than this long conditional note, how about producing two notes here:

note: declare function outside class template to suppress this warning
note: use '<>' to befriend a template specialization

1280–1281

This note should also point out that you need to declare the function template prior to the class template.

include/clang/Sema/Sema.h

10324

This will produce diagnostics in a nondeterministic order, and you have no need of a set because there can never be any duplicates. Just use a SmallVector?

10324

You're missing serialization code for this for the PCH / preamble case.

10326–10327

friends -> friend
template ones -> function templates

lib/Sema/SemaChecking.cpp

12050

This is a huge amount of complexity and maintenance burden for this check, and it still seems to some important cases wrong. Is there a simpler way we can get a largely-equivalent result? Or maybe we can just unconditionally produce both notes?

12282

FriendsOfTemplates.clear() here?

lib/Sema/SemaDecl.cpp

9158–9163

This should also be conditioned on the function having a dependent type and this declaration not being a definition -- this will add all non-template friends to FriendsOfTemplates, whether they're friends of a class template or not.

[sepavloff]

Updated patch

[sepavloff]

Repared file modes.

[sepavloff]

include/clang/Sema/Sema.h

10324

Do we really need it? When compiler is compiling a module containing enclosing class, it must emit these warning, as it does for separate file. The advice it issues is valid in this case also. When compiler compiles code that uses the module, warning is not needed as it must already been issued. So, it looks like serializing this array is not needed.

lib/Sema/SemaChecking.cpp

12050

The visitor class is split into two auxiliary classes. Although amount of code becomes larger, maintainability should be better, as large amount of code is obtained from RecursiveASTVisitor in standard way/ the other is not specific to friend functions.

[sepavloff]

Updated patch

• Remove changes that are not needed anymore,
• Function matching is implemented on recursive function instead of TypeVisitor. It support subset of checks, which should be enough for practical use.
• Added more comments.

include/clang/Basic/DiagnosticGroups.td

 def NullabilityCompleteness : DiagGroup<"nullability-completeness",
                                         [NullabilityCompletenessOnArrays]>;
 def NullArithmetic : DiagGroup<"null-arithmetic">;
 def NullCharacter : DiagGroup<"null-character">;
 def NullDereference : DiagGroup<"null-dereference">;
 def InitializerOverrides : DiagGroup<"initializer-overrides">;
 def NonNull : DiagGroup<"nonnull">;
 def NonPODVarargs : DiagGroup<"non-pod-varargs">;
+def NonTemplateFriend : DiagGroup<"non-template-friend">;
 def ClassVarargs : DiagGroup<"class-varargs", [NonPODVarargs]>;
 def : DiagGroup<"nonportable-cfstrings">;
 def NonVirtualDtor : DiagGroup<"non-virtual-dtor">;
 def : DiagGroup<"effc++", [NonVirtualDtor]>;
 def OveralignedType : DiagGroup<"over-aligned">;
 def AlignedAllocationUnavailable : DiagGroup<"aligned-allocation-unavailable">;
 def OldStyleCast : DiagGroup<"old-style-cast">;
 def : DiagGroup<"old-style-definition">;

include/clang/Basic/DiagnosticSemaKinds.td

def warn_template_qualified_friend_ignored : Warning<
   "dependent nested name specifier '%0' for friend template declaration is "
   "not supported; ignoring this friend declaration">,
   InGroup<UnsupportedFriend>;
 def ext_friend_tag_redecl_outside_namespace : ExtWarn<
   "unqualified friend declaration referring to type outside of the nearest "
   "enclosing namespace is a Microsoft extension; add a nested name specifier">,
   InGroup<MicrosoftUnqualifiedFriend>;
 def err_pure_friend : Error<"friend declaration cannot have a pure-specifier">;
+def warn_non_template_friend : Warning<"friend declaration %q0 depends on "
+  "template parameter but is not a function template">,
+   InGroup<NonTemplateFriend>;
+def note_add_template_friend_decl : Note<"declare function outside class "
+  "template to suppress this warning">;
+def note_befriend_template : Note<"to befriend a template specialization, "
+  "make sure the function template has already been declared and use '<>'">;
 
 def err_invalid_member_in_interface : Error<
   "%select{data member |non-public member function |static member function |"
           "user-declared constructor|user-declared destructor|operator |"
           "nested class }0%1 is not permitted within an interface type">;
 def err_invalid_base_in_interface : Error<
   "interface type cannot inherit from "
   "%select{'struct|non-public 'interface|'class}0 %1'">;
 

include/clang/Sema/Sema.h

private:
   /// \brief Check if the given expression contains 'break' or 'continue'
   /// statement that produces control flow different from GCC.
   void CheckBreakContinueBinding(Expr *E);
 
   /// \brief Check whether receiver is mutable ObjC container which
   /// attempts to add itself into the container
   void CheckObjCCircularContainer(ObjCMessageExpr *Message);
 
+  /// Set of file level friend function declared in template classes and
+  /// dependent on the template parameter.
+  ///
+  /// It is kept to check, if friend function declaration in the code like:
+  /// \code
+  ///     template<typename T> class C {
+  ///       friend void func(T &x);
+  ///     };
+  /// \endcode
+  ///
+  /// is actually intended to be:
+  ///
+  /// \code
+  ///       template<typename T2> friend void func(T2 &x);
+  /// \endcode
+  SmallVector<FunctionDecl *, 16> FriendsOfTemplates;
+
+  /// Check dependent friend functions for misinterpretation as function
+  /// templates.
+  void checkDependentFriends();
+
   void AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE);
   void AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
                                  bool DeleteWasArrayForm);
 public:
   /// \brief Register a magic integral constant to be used as a type tag.
   void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind,
                                   uint64_t MagicValue, QualType Type,
                                   bool LayoutCompatible, bool MustBeNull);

lib/Sema/Sema.cpp

if (ExternalSource) {
                                    Pending.begin(), Pending.end());
     }
     PerformPendingInstantiations();
 
     if (LateTemplateParserCleanup)
       LateTemplateParserCleanup(OpaqueParser);
 
     CheckDelayedMemberExceptionSpecs();
+    checkDependentFriends();
   }
 
   DiagnoseUnterminatedPragmaAttribute();
 
   // All delayed member exception specs should be checked or we end up accepting
   // incompatible declarations.
   // FIXME: This is wrong for TUKind == TU_Prefix. In that case, we need to
   // write out the lists to the AST file (if any).

lib/Sema/SemaChecking.cpp

void Sema::AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,
                                          CharUnits Alignment) {
   MisalignedMembers.emplace_back(E, RD, MD, Alignment);
 }
 
 void Sema::DiagnoseMisalignedMembers() {
   for (MisalignedMember &m : MisalignedMembers) {
     const NamedDecl *ND = m.RD;
     if (ND->getName().empty()) {
       if (const TypedefNameDecl *TD = m.RD->getTypedefNameForAnonDecl())
         ND = TD;
     }
     Diag(m.E->getLocStart(), diag::warn_taking_address_of_packed_member)
         << m.MD << ND << m.E->getSourceRange();
   }
   MisalignedMembers.clear();
 }
 

 
 void Sema::CheckAddressOfPackedMember(Expr *rhs) {
   using namespace std::placeholders;
   RefersToMemberWithReducedAlignment(
       rhs, std::bind(&Sema::AddPotentialMisalignedMembers, std::ref(*this), _1,
                      _2, _3, _4));
 }
 
+
+namespace {
+/// Helper class used to check if a friend declaration may refer to another
+/// function declaration.
+///
+/// The class is used to compare two function declarations, one is a friend
+/// function declared in template class, the other is a function with the same
+/// name declared at file level.
+///
+/// The class is used to produce appropriate warning if friend function declared
+/// in a template class depends on that class template parameters.
+///
+class FunctionMatcher {
+  ASTContext &Ctx;
+  std::map<const TemplateTypeParmType *, QualType> TemplParamMapping;
+
+  bool match(QualType TFriend, QualType TFunc) {
+    if (TFriend == TFunc)
+      return true;
+    if (TFriend.getQualifiers() != TFunc.getQualifiers())
+      return false;
+    if (auto FrT = TFriend->getAs<TemplateTypeParmType>()) {
+      if (auto FT = TFunc->getAs<TemplateTypeParmType>())
+        return FrT->getDepth() == FT->getDepth() &&
+        FrT->getIndex() == FT->getIndex();
+
+      const TemplateTypeParmType *CanonFrTParm = cast<TemplateTypeParmType>(
+        FrT->getCanonicalTypeUnqualified().getTypePtr());
+      CanQualType CanonFT = TFunc->getCanonicalTypeUnqualified();
+      auto Ptr = TemplParamMapping.find(CanonFrTParm);
+      if (Ptr != TemplParamMapping.end())
+        return Ptr->second == CanonFT;
+      TemplParamMapping[CanonFrTParm] = CanonFT;
+      return true;
+    }
+    if (auto FrPT = TFriend->getAs<PointerType>()) {
+      if (auto PT = TFunc->getAs<PointerType>())
+        return match(FrPT->getPointeeType(), PT->getPointeeType());
+      return false;
+    }
+    if (auto FrLR = TFriend->getAs<LValueReferenceType>()) {
+      if (auto LR = TFunc->getAs<LValueReferenceType>())
+        return match(FrLR->getPointeeType(), LR->getPointeeType());
+      return false;
+    }
+    if (auto FrRR = TFriend->getAs<RValueReferenceType>()) {
+      if (auto RR = TFunc->getAs<RValueReferenceType>())
+        return match(FrRR->getPointeeType(), RR->getPointeeType());
+      return false;
+    }
+    if (auto FrT = TFriend->getAs<InjectedClassNameType>()) {
+      QualType FrT2 = Ctx.getQualifiedType(FrT->getInjectedSpecializationType(),
+                                           TFriend.getQualifiers());
+      return match(FrT2, TFunc);
+    }
+    if (auto FrT = TFriend->getAs<FunctionProtoType>()) {
+      if (auto FT = TFunc->getAs<FunctionProtoType>()) {
+        if (FrT->getNumParams() != FT->getNumParams())
+          return false;
+        for (unsigned I = 0, E = FT->getNumParams(); I < E; ++I) {
+          if (!match(FrT->getParamType(I), FT->getParamType(I)))
+            return false;
+        }
+        return match(FrT->getReturnType(), FT->getReturnType());
+      }
+      return false;
+    }
+    if (auto *FrT = TFriend->getAs<TemplateSpecializationType>()) {
+      if (auto FT = TFunc->getAs<TemplateSpecializationType>()) {
+        TemplateName FrTN = FrT->getTemplateName();
+        TemplateName FTN = FT->getTemplateName();
+        if (FrTN.getKind() != TemplateName::Template ||
+            FrTN.getKind() != FTN.getKind())
+          return false;
+        if (FrTN.isInstantiationDependent() || FTN.isInstantiationDependent())
+          return false;
+        const Decl *FrD = FrTN.getAsTemplateDecl()->getCanonicalDecl();
+        const Decl *FD = FTN.getAsTemplateDecl()->getCanonicalDecl();
+        if (FrD != FD)
+          return false;
+
+        auto IFrT = FrT->begin(), EFrT = FrT->end();
+        auto IFT = FT->begin();
+        for (; IFrT != EFrT; ++IFrT, ++IFT) {
+          assert(IFT != FT->end());
+          const TemplateArgument &FrTA = *IFrT;
+          const TemplateArgument &FTA = *IFT;
+          if (FrTA.getKind() != FTA.getKind())
+            return false;
+          if (FrTA.getKind() == TemplateArgument::Type) {
+            QualType FrTy = FrTA.getAsType();
+            QualType FTy = FTA.getAsType();
+            if (!match(FrTy, FTy))
+              return false;
+          } else if (FrTA.getKind() == TemplateArgument::Integral) {
+            if (FrTA.getIntegralType() != FTA.getIntegralType())
+              return false;
+            llvm::APSInt FrV = FrTA.getAsIntegral();
+            llvm::APSInt FV = FTA.getAsIntegral();
+            if (FrV != FV)
+              return false;
+          } else
+            return false;
+        }
+        return true;
+      }
+      return false;
+    }
+
+    return false;
+  }
+
+public:
+  FunctionMatcher (ASTContext &Ctx) : Ctx(Ctx) {}
+
+  bool isPossibleMatch(FunctionDecl *FrD, FunctionDecl *F) {
+    TemplParamMapping.clear();
+    return match(FrD->getType(), F->getType());
+  }
+
+  bool isPossibleMatch(FunctionDecl *FrD, FunctionTemplateDecl *F) {
+    TemplParamMapping.clear();
+    FunctionDecl *Pattern = F->getTemplatedDecl();
+    return match(FrD->getType(), Pattern->getType());
+  }
+};
+}
+
+/// Given a friend function declaration checks if it might be misused.
+static void checkDependentFriend(Sema &S, FunctionDecl *FriendD) {
+  if (FriendD->isInvalidDecl())
+    return;
+
+  // Scan all function and function template declarations with the same name as
+  // the specified friend function to see if some of them could be referenced in
+  // the friend declaration.
+  LookupResult FRes(S, FriendD->getNameInfo(), Sema::LookupOrdinaryName);
+  if (S.LookupQualifiedName(FRes, FriendD->getDeclContext())) {
+
+    // First check for suitable functions that uses particular specialization of
+    // parameter type, for example:
+    //
+    //     template<typename T> class C {
+    //         friend void func(T &x);
+    //     };
+    //     void func(int &x);
+    //
+    // Presence of such function can be considered as an evidence that the
+    // friend function is dependent intentionally. No warning in this case.
+    for (NamedDecl *D : FRes) {
+      if (D->isInvalidDecl())
+        continue;
+      if (auto *FD = dyn_cast<FunctionDecl>(D)) {
+        if (FunctionMatcher(S.getASTContext()).isPossibleMatch(FriendD, FD))
+          return;
+      }
+    }
+
+    // Next check if there is suitable function template, like:
+    //
+    //     template<typename T> class C {
+    //         friend void func(T &x);
+    //     };
+    //     template<typename T> void func(T &x);
+    //
+    // If such template exists, issue warning and propose the template as a
+    // friend.
+    for (NamedDecl *D : FRes) {
+      if (D->isInvalidDecl())
+        continue;
+      if (auto *FTD = dyn_cast<FunctionTemplateDecl>(D))
+        if (FunctionMatcher(S.getASTContext()).isPossibleMatch(FriendD, FTD)) {
+          // Appropriate function template is found.
+          S.Diag(FriendD->getLocation(), diag::warn_non_template_friend)
+              << FriendD;
+          SourceLocation NameLoc = FriendD->getNameInfo().getLocEnd();
+          SourceLocation PastName = S.getLocForEndOfToken(NameLoc);
+          S.Diag(PastName, diag::note_befriend_template)
+            << FixItHint::CreateInsertion(PastName, "<>");
+          return;
+        }
+    }
+  }
+
+  // No appropriate function or function template was found, so issue generic
+  // warning.
+  S.Diag(FriendD->getLocation(), diag::warn_non_template_friend) << FriendD;
+  S.Diag(FriendD->getLocation(), diag::note_add_template_friend_decl);
+  S.Diag(FriendD->getLocation(), diag::note_befriend_template);
+}
+
+
+void Sema::checkDependentFriends() {
+  for (FunctionDecl *FriendD : FriendsOfTemplates) {
+    if (FriendD->getType()->isDependentType() &&
+        !FriendD->isThisDeclarationADefinition())
+      checkDependentFriend(*this, FriendD);
+  }
+  FriendsOfTemplates.clear();
+}

lib/Sema/SemaDecl.cpp

ClassScopeFunctionSpecializationDecl *NewSpec =
                          ClassScopeFunctionSpecializationDecl::Create(
                                 Context, CurContext, SourceLocation(),
                                 cast<CXXMethodDecl>(NewFD),
                                 HasExplicitTemplateArgs, TemplateArgs);
     CurContext->addDecl(NewSpec);
     AddToScope = false;
   }
 
+  // If this is a friend function declaration inside a template class and the
+  // function depends on the template parameter as in:
+  //
+  //     template<typename T> class C {
+  //         friend void func(T &x);
+  //     };
+  //
+  // store it in the Sema. Later on such declaration will be checked if it is
+  // a misprint of a function template.
+  if (isFriend && !NewFD->isInvalidDecl()) {
+    if (TemplateParamLists.empty() &&
+        !DC->isRecord() &&
+        !isFunctionTemplateSpecialization &&
+        NewFD->getType()->isDependentType() &&
+        !NewFD->isThisDeclarationADefinition()) {
+      FriendsOfTemplates.push_back(NewFD);
+    }
+  }
+
   return NewFD;
 }
 
 /// \brief Checks if the new declaration declared in dependent context must be
 /// put in the same redeclaration chain as the specified declaration.
 ///
 /// \param D Declaration that is checked.
 /// \param PrevDecl Previous declaration found with proper lookup method for the

test/CXX/drs/dr3xx.cpp

namespace N {
     void f(A<0>::B<0>);
   }
   template<> template<> struct N::A<0>::B<0> {};
 
   template<typename T> void g(T t) { f(t); }
   template void g(N::A<0>::B<0>);
 
   namespace N {
-    template<typename> struct I { friend bool operator==(const I&, const I&); };
+    template<typename> struct I { friend bool operator==(const I&, const I&); };  // expected-warning{{friend declaration 'dr321::N::operator==' depends on template parameter but is not a function template}}
+                                      // expected-note@-1{{declare function outside class template to suppress this warning}}
+                                      // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
   }
   N::I<int> i, j;
   bool x = i == j;
 }
 
 namespace dr322 { // dr322: yes
   struct A {
     template<typename T> operator T&();

test/CXX/drs/dr5xx.cpp

struct namespace_scope {
     friend void *operator new(size_t, namespace_scope); // expected-error {{cannot be declared inside a namespace}}
   };
 }
 
 // dr556: na
 
 namespace dr557 { // dr557: yes
   template<typename T> struct S {
-    friend void f(S<T> *);
-    friend void g(S<S<T> > *);
+    friend void f(S<T> *);  // expected-warning{{friend declaration 'dr557::f' depends on template parameter but is not a function template}}
+                            // expected-note@-1{{declare function outside class template to suppress this warning}}
+                            // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
+    friend void g(S<S<T> > *); // expected-warning{{friend declaration 'dr557::g' depends on template parameter but is not a function template}}
+                               // expected-note@-1{{declare function outside class template to suppress this warning}}
+                               // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
   };
   void x(S<int> *p, S<S<int> > *q) {
     f(p);
     g(q);
   }
 }
 
 namespace dr558 { // dr558: yes

test/CXX/temp/temp.res/p3.cpp

-// RUN: %clang_cc1 -verify %s -std=c++11
+// RUN: %clang_cc1 -verify %s -std=c++11 -Wno-non-template-friend
 
 template<typename T> struct A {
   template<typename U> struct B;
   template<typename U> using C = U; // expected-note {{here}}
 };
 
 struct X {
   template<typename T> X(T);

test/SemaCXX/friend.cpp

 namespace default_arg {
   void f();
   void f(void*); // expected-note {{previous}}
   struct X {
     friend void f(int a, int b = 0) {}
     friend void f(void *p = 0) {} // expected-error {{must be the only}}
   };
 }
+
+template<typename T> void pr23342_func(T x);
+template<typename T>
+struct pr23342_C1 {
+  friend void pr23342_func<>(T x);
+  friend bool func(T x);  // expected-warning{{friend declaration 'func' depends on template parameter but is not a function template}}
+                          // expected-note@-1{{declare function outside class template to suppress this warning}}
+                          // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
+  friend bool func2(int x);
+  template<typename T2> friend bool func3(T2 x);
+  friend T func4();  // expected-warning{{friend declaration 'func4' depends on template parameter but is not a function template}}
+                     // expected-note@-1{{declare function outside class template to suppress this warning}}
+                     // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
+};
+
+namespace pr23342 {
+
+template<typename T>
+struct C1 {
+  friend void pr23342_func<>(T x);
+  friend bool func(T x);  // expected-warning{{friend declaration 'pr23342::func' depends on template parameter but is not a function template}}
+                          // expected-note@-1{{declare function outside class template to suppress this warning}}
+                          // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
+  friend bool func2(int x);
+  template<typename T2> friend bool func3(T2 x);
+  friend T func4();    // expected-warning{{friend declaration 'pr23342::func4' depends on template parameter but is not a function template}}
+                       // expected-note@-1{{declare function outside class template to suppress this warning}}
+                       // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
+};
+
+template <typename T>
+struct Arg {
+  friend bool operator==(const Arg& lhs, T rhs) {
+   return false;
+  }
+  friend bool operator!=(const Arg& lhs, T rhs);  // expected-warning{{friend declaration 'pr23342::operator!=' depends on template parameter but is not a function template}}
+                       // expected-note@-1{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
+};
+template <typename T>
+bool operator!=(const Arg<T>& lhs, T rhs) {
+  return true;
+}
+bool foo() {
+  Arg<int> arg;
+  return (arg == 42) || (arg != 42);
+}
+
+
+template<typename T> class C0 {
+  friend void func0(C0<T> &);  // expected-warning{{friend declaration 'pr23342::func0' depends on template parameter but is not a function template}}
+                               // expected-note@-1{{declare function outside class template to suppress this warning}}
+                               // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
+};
+
+template<typename T> class C0a {
+  friend void func0a(C0a<T> &);  // expected-warning{{friend declaration 'pr23342::func0a' depends on template parameter but is not a function template}}
+                                 // expected-note@-1{{declare function outside class template to suppress this warning}}
+                                 // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
+};
+void func0a(C0a<int> x);
+void func0a(C0a<int> *x);
+void func0a(const C0a<int> &x);
+int func0a(C0a<int> &x);
+
+template<typename T> class C0b {
+  friend void func0b(C0b<T> &x);
+};
+void func0b(C0b<int> &x);
+
+
+template<typename T> class C1a {
+  friend void func1a(T x, C1a<T> &y); // expected-warning{{friend declaration 'pr23342::func1a' depends on template parameter but is not a function template}}
+                                      // expected-note@-1{{declare function outside class template to suppress this warning}}
+                                      // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
+};
+void func1a(char x, C1a<int> &y);
+
+template<typename T> class C1b {
+  friend void func1b(T x, C1b<T> &y);
+};
+void func1b(int x, C1b<int> &y);
+
+
+template<typename T> class C2a {
+  friend void func2a(C2a<T> &); // expected-warning{{friend declaration 'pr23342::func2a' depends on template parameter but is not a function template}}
+                                // expected-note@-1{{declare function outside class template to suppress this warning}}
+                                // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
+};
+template<typename T>
+void func2a(const C2a<T> &x);
+
+
+template<typename T> class C2b {
+  friend void func2b(C2b<T> &); // expected-warning{{friend declaration 'pr23342::func2b' depends on template parameter but is not a function template}}
+                                // expected-note@-1{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}};
+};
+template<typename T>
+void func2b(C2b<T> &x);
+
+template<typename T> class C2c;
+template<typename T>
+void func2c(C2c<T> &x);
+template<typename T> class C2c {
+  friend void func2c<>(C2c<T> &);
+};
+
+template<typename T> class C3 {
+  friend void func3(T &);
+};
+void func3(int &);
+template<typename T> void func3(T &);
+
+}

test/SemaCXX/overload-call.cpp

void bar() {
     int &ir = (&foo)(0);
   }
 }
 
 namespace IncompleteArg {
   // Ensure that overload resolution attempts to complete argument types when
   // performing ADL.
   template<typename T> struct S {
-    friend int f(const S&);
+    friend int f(const S&);  // expected-warning{{friend declaration 'IncompleteArg::f' depends on template parameter but is not a function template}}
+                             // expected-note@-1{{declare function outside class template to suppress this warning}}
+                             // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
   };
   extern S<int> s;
   int k = f(s);
 
   template<typename T> struct Op {
-    friend bool operator==(const Op &, const Op &);
+    friend bool operator==(const Op &, const Op &);  // expected-warning{{friend declaration 'IncompleteArg::operator==' depends on template parameter but is not a function template}}
+                             // expected-note@-1{{declare function outside class template to suppress this warning}}
+                             // expected-note@-2{{to befriend a template specialization, make sure the function template has already been declared and use '<>'}}
   };
   extern Op<char> op;
   bool b = op == op;
 
   // ... and not in other cases! Nothing here requires U<int()> to be complete.
   // (Note that instantiating U<int()> will fail.)
   template<typename T> struct U {
     T t;