Fix instantiation of friend function templates

[sepavloff]

Summary

This change fixed function template instantiation if the template is
defined in a friend declaration inside a class template.

Instantiation of friend templates defined inline in general requires
knowledge of the class template specialization where the template body is
defined. For instance, in the code:

template<typename T> struct C {
    template<typename T1> friend void func(T1 *x) { T var; }
};
C<int> v;
void use(int *x) { func(x); }

To properly instantiate func it is necessary to know in which
particular specialization of the containing class C the function
template is defined, because its body depends on template parameter
of that class. However the pattern search made by
getTemplateInstantiationPattern end up with the definition in
template class and information about its specialization is lost.
Subsequent call to getTemplateInstantiationArgs does not have
actual information and cannot instantiate the function.

As a solution, this change adds additional argument to the function
getTemplateInstantiationPattern that is set to the class template
specialization if the function is defined in its friend declaration.
Similarly the function getTemplateInstantiationArgs gets additional
argument, which specifies this specialization.

This change fixes PR26512, PR19095 and PR34343.

[sepavloff]

Aligned implementation with D21508.

[sepavloff]

Reworked patch

Used more general way to cope with calculation of instantiation
stack, which is suitable for cases represented in PR26512.

Added new tests.

[sepavloff]

Added regression test for PR34343

Investigation of this defect is presented in https://bugs.llvm.org/show_bug.cgi?id=34343 .

[sepavloff]

Rebased patch

[sepavloff]

Rebased the patch, it is still actual.

[rjmccall]

Shouldn't there just be a link in the AST from the instantiated FunctionTemplateDecl back to the original pattern? Maybe a generalization of InstantiatedFromMember in RedeclarablableTemplateDecl?

[sepavloff]

In D21767#1197783, @rjmccall wrote:

Shouldn't there just be a link in the AST from the instantiated FunctionTemplateDecl back to the original pattern? Maybe a generalization of InstantiatedFromMember in RedeclarablableTemplateDecl?

The field InstantiatedFromMember indeed helps finding function template definition, this patch only modifies search algorithm to make it suitable for friend templates. Friend function templates have dual nature, they may be members of redeclaration chains, like usual namespace level function templates and still use InstantiatedFromMember like member function templates. So the resulting search algorithm (implemented in getPatternFor) scans both redeclaration chain and the chain formed by InstantiatedFromMember.

[rjmccall]

Oh, I see. The code currently tries to work with just the specialization and the pattern. To do the instantiation, we have to find template arguments for the context in which the pattern appears. For function temploids that aren't defined in a friend declaration, we can just consider the semantic DC hierarchy of the specialization, which will be the same across all redeclarations. For function temploids that *are* defined in a friend declaration, we have to look at the lexical DC of the declaration that was actually instantiated from the class temploid that defined the friend function, which isn't necessarily the specialization because it might have been redeclared after the friend function was instantiated. So your patch is mostly just changing the find-the-pattern lookup to remember that lexical DC when we find a pattern this way, which seems sensible. Richard should look over the actual lookup-algorithm changes.

include/clang/AST/Decl.h

2443

"If this is non-null and the pattern is a friend function declaration, this is set to the class containing the friend declaration."

lib/AST/Decl.cpp

3389

I don't think this can fail; a friend should always be lexically nested in a class.

3399

It's unfortunate that this needs to walk the redeclaration chain itself looking for definitions. Can't you just call getDefinition to find the definition and then run your extra checks on that?

3444

Same observation.

include/clang/AST/ASTLambda.h

if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D))
     return isLambdaConversionOperator(Conv);
   if (FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(D))
     if (CXXConversionDecl *Conv =
         dyn_cast_or_null<CXXConversionDecl>(F->getTemplatedDecl()))
       return isLambdaConversionOperator(Conv);
   return false;
 }
 
-inline bool isGenericLambdaCallOperatorSpecialization(DeclContext *DC) {
+inline bool isGenericLambdaCallOperatorSpecialization(const DeclContext *DC) {
   return isGenericLambdaCallOperatorSpecialization(
                                           dyn_cast<CXXMethodDecl>(DC));
 }
 
 
 // This returns the parent DeclContext ensuring that the correct
 // parent DeclContext is returned for Lambdas
 inline DeclContext *getLambdaAwareParentOfDeclContext(DeclContext *DC) {

include/clang/AST/Decl.h

public:
 
   /// Determines if the given function was instantiated from a
   /// function template.
   bool isTemplateInstantiation() const;
 
   /// Retrieve the function declaration from which this function could
   /// be instantiated, if it is an instantiation (rather than a non-template
   /// or a specialization, for example).
-  FunctionDecl *getTemplateInstantiationPattern() const;
+  ///
+  /// \param[out] HostForFriend If it is not null, the pattern is found and is
+  /// defined in a friend declaration, this parameter is assigned pointer to the
+  /// class containing the friend declaration.
+  ///
+  FunctionDecl *getTemplateInstantiationPattern(
+                           const CXXRecordDecl **HostForFriend = nullptr) const;
 
   /// Retrieve the primary template that this function template
   /// specialization either specializes or was instantiated from.
   ///
   /// If this function declaration is not a function template specialization,
   /// returns NULL.
   FunctionTemplateDecl *getPrimaryTemplate() const;
 

include/clang/Sema/Sema.h

   //===--------------------------------------------------------------------===//
   // C++ Template Instantiation
   //
 
   MultiLevelTemplateArgumentList
   getTemplateInstantiationArgs(NamedDecl *D,
                                const TemplateArgumentList *Innermost = nullptr,
                                bool RelativeToPrimary = false,
-                               const FunctionDecl *Pattern = nullptr);
+                               const FunctionDecl *Pattern = nullptr,
+                               const CXXRecordDecl *HostForFriend = nullptr);
 
   /// A context in which code is being synthesized (where a source location
   /// alone is not sufficient to identify the context). This covers template
   /// instantiation and various forms of implicitly-generated functions.
   struct CodeSynthesisContext {
     /// The kind of template instantiation we are performing
     enum SynthesisKind {
       /// We are instantiating a template declaration. The entity is

lib/AST/Decl.cpp

switch (getTemplateSpecializationKind()) {
     case TSK_ImplicitInstantiation:
     case TSK_ExplicitInstantiationDeclaration:
     case TSK_ExplicitInstantiationDefinition:
       return true;
   }
   llvm_unreachable("All TSK values handled.");
 }
 
-FunctionDecl *FunctionDecl::getTemplateInstantiationPattern() const {
+static FunctionTemplateDecl *getPatternFor(FunctionTemplateDecl *FTD,
+                                           const CXXRecordDecl *&Host) {
+  Host = nullptr;
+  for (auto I : FTD->redecls()) {
+    auto D = cast<FunctionTemplateDecl>(I);
+    // If we have hit a point where the user provided a specialization of
+    // this template, we're done looking.
+    if (D->isMemberSpecialization())
+      return D;
+    if (D->isThisDeclarationADefinition())
+      return D;
+    if (FunctionTemplateDecl *Orig = D->getInstantiatedFromMemberTemplate()) {
+      if (Orig->getFriendObjectKind() != Decl::FOK_None) {
+        if (auto *RDC = dyn_cast<CXXRecordDecl>(D->getLexicalDeclContext()))
+          Host = RDC;
+        else
+          continue;
+      }
+      const CXXRecordDecl *OrigHost;
+      if (FunctionTemplateDecl *Def = getPatternFor(Orig, OrigHost)) {
+        if (OrigHost)
+          Host = OrigHost;
+        return Def;
+      }
+    }
+  }
+  return nullptr;
+}
+
+FunctionDecl *FunctionDecl::getTemplateInstantiationPattern(
+                                    const CXXRecordDecl **HostForFriend) const {
+  if (HostForFriend)
+    *HostForFriend = nullptr;
+
   // Handle class scope explicit specialization special case.
   if (getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
     if (auto *Spec = getClassScopeSpecializationPattern())
       return getDefinitionOrSelf(Spec);
     return nullptr;
   }
 
   // If this is a generic lambda call operator specialization, its
   // instantiation pattern is always its primary template's pattern
   // even if its primary template was instantiated from another
   // member template (which happens with nested generic lambdas).
   // Since a lambda's call operator's body is transformed eagerly,
   // we don't have to go hunting for a prototype definition template
   // (i.e. instantiated-from-member-template) to use as an instantiation
   // pattern.
 
   if (isGenericLambdaCallOperatorSpecialization(
           dyn_cast<CXXMethodDecl>(this))) {
     assert(getPrimaryTemplate() && "not a generic lambda call operator?");
     return getDefinitionOrSelf(getPrimaryTemplate()->getTemplatedDecl());
   }
 
   if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) {
-    while (Primary->getInstantiatedFromMemberTemplate()) {
-      // If we have hit a point where the user provided a specialization of
-      // this template, we're done looking.
-      if (Primary->isMemberSpecialization())
-        break;
-      Primary = Primary->getInstantiatedFromMemberTemplate();
+    const CXXRecordDecl *Host;
+    if (FunctionTemplateDecl *Def = getPatternFor(Primary, Host)) {
+      if (HostForFriend)
+        *HostForFriend = Host;
+      Primary = Def;
     }
-
     return getDefinitionOrSelf(Primary->getTemplatedDecl());
   }
 
-  if (auto *MFD = getInstantiatedFromMemberFunction())
+  if (auto *MFD = getInstantiatedFromMemberFunction()) {
+    if (MFD->getFriendObjectKind() != Decl::FOK_None)
+      if (auto *DC = dyn_cast<CXXRecordDecl>(getLexicalDeclContext()))
+        if (HostForFriend)
+          *HostForFriend = DC;
     return getDefinitionOrSelf(MFD);
+  }
 
   return nullptr;
 }
 
 FunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const {
   if (FunctionTemplateSpecializationInfo *Info
         = TemplateOrSpecialization
             .dyn_cast<FunctionTemplateSpecializationInfo*>()) {

lib/Sema/SemaTemplateInstantiate.cpp

 /// \param Pattern If non-NULL, indicates the pattern from which we will be
 /// instantiating the definition of the given declaration, \p D. This is
 /// used to determine the proper set of template instantiation arguments for
 /// friend function template specializations.
 MultiLevelTemplateArgumentList
 Sema::getTemplateInstantiationArgs(NamedDecl *D,
                                    const TemplateArgumentList *Innermost,
                                    bool RelativeToPrimary,
-                                   const FunctionDecl *Pattern) {
+                                   const FunctionDecl *Pattern,
+                                   const CXXRecordDecl *HostForFriend) {
   // Accumulate the set of template argument lists in this structure.
   MultiLevelTemplateArgumentList Result;
 
   if (Innermost)
     Result.addOuterTemplateArguments(Innermost);
 
   DeclContext *Ctx = dyn_cast<DeclContext>(D);
   if (!Ctx) {
if (Ctx->isTranslationUnit()) {
           Result.addOuterTemplateArguments(None);
         return Result;
       }
     }
   }
 
   while (!Ctx->isFileContext()) {
     // Add template arguments from a class template instantiation.
-    if (ClassTemplateSpecializationDecl *Spec
-          = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
+    if (auto Spec = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
       // We're done when we hit an explicit specialization.
       if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
           !isa<ClassTemplatePartialSpecializationDecl>(Spec))
         break;
 
       Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
 
       // If this class template specialization was instantiated from a
       // specialized member that is a class template, we're done.
       assert(Spec->getSpecializedTemplate() && "No class template?");
       if (Spec->getSpecializedTemplate()->isMemberSpecialization())
         break;
     }
     // Add template arguments from a function template specialization.
-    else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
+    else if (auto Function = dyn_cast<FunctionDecl>(Ctx)) {
       if (!RelativeToPrimary &&
           (Function->getTemplateSpecializationKind() ==
                                                   TSK_ExplicitSpecialization &&
            !Function->getClassScopeSpecializationPattern()))
         break;
 
       if (const TemplateArgumentList *TemplateArgs
             = Function->getTemplateSpecializationArgs()) {
else if (auto Function = dyn_cast<FunctionDecl>(Ctx)) {
           break;
 
       } else if (FunctionTemplateDecl *FunTmpl
                                    = Function->getDescribedFunctionTemplate()) {
         // Add the "injected" template arguments.
         Result.addOuterTemplateArguments(FunTmpl->getInjectedTemplateArgs());
       }
 
-      // If this is a friend declaration and it declares an entity at
-      // namespace scope, take arguments from its lexical parent
-      // instead of its semantic parent, unless of course the pattern we're
-      // instantiating actually comes from the file's context!
-      if (Function->getFriendObjectKind() &&
-          Function->getDeclContext()->isFileContext() &&
-          (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
-        Ctx = Function->getLexicalDeclContext();
+      // If instantiated function is at namespace scope, its pattern may be
+      // defined in friend declaration. In this case arguments are taken from
+      // the class containing the friend declaration.
+      if (Function->getDeclContext()->isFileContext()) {
+        if (HostForFriend) {
+          Ctx = const_cast<DeclContext*>(cast<DeclContext>(HostForFriend));
           RelativeToPrimary = false;
           continue;
         }
-    } else if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
+      }
+    } else if (auto *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
       if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
         QualType T = ClassTemplate->getInjectedClassNameSpecialization();
         const TemplateSpecializationType *TST =
             cast<TemplateSpecializationType>(Context.getCanonicalType(T));
         Result.addOuterTemplateArguments(
             llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs()));
         if (ClassTemplate->isMemberSpecialization())
           break;

lib/Sema/SemaTemplateInstantiateDecl.cpp

void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
   // Never instantiate an explicit specialization except if it is a class scope
   // explicit specialization.
   TemplateSpecializationKind TSK = Function->getTemplateSpecializationKind();
   if (TSK == TSK_ExplicitSpecialization &&
       !Function->getClassScopeSpecializationPattern())
     return;
 
   // Find the function body that we'll be substituting.
-  const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
+  const CXXRecordDecl *HostOfFriend;
+  const FunctionDecl *PatternDecl =
+      Function->getTemplateInstantiationPattern(&HostOfFriend);
   assert(PatternDecl && "instantiating a non-template");
 
   const FunctionDecl *PatternDef = PatternDecl->getDefinition();
   Stmt *Pattern = nullptr;
   if (PatternDef) {
     Pattern = PatternDef->getBody(PatternDef);
     PatternDecl = PatternDef;
     if (PatternDef->willHaveBody())
if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
     MergeWithParentScope = Rec->isLocalClass();
 
   LocalInstantiationScope Scope(*this, MergeWithParentScope);
 
   if (PatternDecl->isDefaulted())
     SetDeclDefaulted(Function, PatternDecl->getLocation());
   else {
     MultiLevelTemplateArgumentList TemplateArgs =
-      getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);
+      getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl,
+                                   HostOfFriend);
 
     // Substitute into the qualifier; we can get a substitution failure here
     // through evil use of alias templates.
     // FIXME: Is CurContext correct for this? Should we go to the (instantiation
     // of the) lexical context of the pattern?
     SubstQualifier(*this, PatternDecl, Function, TemplateArgs);
 
     ActOnStartOfFunctionDef(nullptr, Function);

test/SemaTemplate/instantiate-friend-function.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
-// RUN: %clang_cc1 -S -triple %itanium_abi_triple -std=c++11 -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -fcxx-exceptions %s
+// RUN: %clang_cc1 -S -triple %itanium_abi_triple -std=c++11 -fcxx-exceptions -emit-llvm %s -o - | FileCheck %s
 // expected-no-diagnostics
 
 namespace PR10856 {
   template<typename T> class C;
 
   template<typename S, typename R = S> C<R> operator - (C<S> m0, C<S> m1);
   template<typename T> class C {
     public:
namespace PR10856_Root {
   void f() {
     MyClass<int> value;
     g(value);
   }
 }
 
 // bool PR10856_Root::g<PR10856_Root::MyClass<int>, void>(PR10856_Root::MyClass<int>)
 // CHECK: call {{.*}} @_ZN12PR10856_Root1gINS_7MyClassIiEEvEEbT_
+
+// Instantiate friend function, pattern is at file level.
+
+
+template<typename T> struct C01 {
+  template<typename T1> friend void func_01(C01<T> &, T1);
+  template<typename T1, typename T2> friend void func_01a(C01<T1> &, T2);
+};
+
+C01<int> c01;
+
+void f_01() {
+  func_01(c01, 0.0);
+  func_01a(c01, 0.0);
+}
+
+template<typename T1> void func_01(C01<int> &, T1) {}
+template<typename T1, typename T2> void func_01a(C01<T1> &, T2) {}
+
+// void func_01<double>(C01<int>&, double)
+// CHECK: define linkonce_odr void @_Z7func_01IdEvR3C01IiET_
+//
+// void func_01a<int, double>(C01<int>&, double)
+// CHECK: define linkonce_odr void @_Z8func_01aIidEvR3C01IT_ET0_
+
+
+template<typename T> struct C02 {
+  template<typename T1> friend void func_02(const C02<T> &, T1) { T var; }
+  template<typename T1, typename T2> friend void func_02a(const C02<T1> &, T2) { T var; }
+  template<typename T1> friend constexpr unsigned func_02b(const C02<T> &, const T1 x) { return sizeof(T1); }
+};
+
+const C02<int> c02;
+
+void f_02() {
+  func_02(c02, 0.0);
+  func_02a(c02, 0.0);
+  static_assert(func_02b(c02, short(122)) == sizeof(short), "Invalid calculation");
+  static_assert(func_02b(c02, 122L) == sizeof(long), "Invalid calculation");
+}
+
+// void func_02<double>(C02<int> const&, double)
+// CHECK: define linkonce_odr void @_Z7func_02IdEvRK3C02IiET_
+//
+// void func_02a<int, double>(C02<int> const&, double)
+// CHECK: define linkonce_odr void @_Z8func_02aIidEvRK3C02IT_ET0_
+
+
+template<typename T> struct C03 {
+  template<typename T1> friend void func_03(C03<T> &, T1);
+  template<typename T1, typename T2> friend void func_03a(C03<T1> &, T2);
+};
+
+C03<int> c03;
+
+void f_03() {
+  func_03(c03, 0.0);
+  func_03a(c03, 0.0);
+}
+
+template<typename T> struct C03A {
+  template<typename T1> friend void func_03(C03<T> &, T1) { }
+};
+template<typename T> struct C03B {
+  template<typename T1, typename T2> friend void func_03a(C03<T1> &, T2) { T var; }
+};
+
+C03A<int> c03a;
+C03B<int> c03b;
+
+// void func_03<double>(C03<int>&, double)
+// CHECK: define linkonce_odr void @_Z7func_03IdEvR3C03IiET_
+//
+// void func_03a<int, double>(C03<int>&, double)
+// CHECK: define linkonce_odr void @_Z8func_03aIidEvR3C03IT_ET0_
+
+
+// File level declaration, friend pattern.
+
+
+template<typename T1> void func_10(T1 *x);
+template<typename T1, typename T2> void func_10a(T1 *x, T2 *y);
+template<typename T1> constexpr unsigned func_10b(const T1 x);
+template<typename T1> constexpr unsigned func_10c(const T1 x);
+
+template<typename T>
+struct C10 {
+  template<typename T1> friend void func_10(T1 *x) { T var; }
+  template<typename T1, typename T2> friend void func_10a(T1 *x, T2 *y) { T var; }
+  template<typename T1> friend constexpr unsigned func_10b(const T1 x) { return sizeof(T1); }
+  template<typename T1> friend constexpr unsigned func_10c(const T1 x) { return sizeof(T); }
+};
+
+C10<int> v10;
+
+void use_10(int *x) {
+  func_10(x);
+  func_10a(x, &x);
+  static_assert(func_10b(short(122)) == sizeof(short), "Invalid calculation");
+  static_assert(func_10b(122L) == sizeof(long), "Invalid calculation");
+  static_assert(func_10c(short(122)) == sizeof(int), "Invalid calculation");
+  static_assert(func_10c(122L) == sizeof(int), "Invalid calculation");
+}
+
+// void func_10<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_10IiEvPT_
+//
+// void func_10a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_10aIiPiEvPT_PT0_
+
+
+template<typename T>
+struct C11 {
+  template<typename T1> friend void func_11(T1 *x) { T var; }
+  template<typename T1, typename T2> friend void func_11a(T1 *x, T2 *y) { T var; }
+  template<typename T1> friend constexpr unsigned func_11b(const T1 x) { return sizeof(T1); }
+  template<typename T1> friend constexpr unsigned func_11c(const T1 x) { return sizeof(T); }
+};
+
+C11<int> v11;
+
+template<typename T> void func_11(T *x);
+template<typename T1, typename T2> void func_11a(T1 *x, T2 *y);
+template<typename T1> constexpr unsigned func_11b(const T1 x);
+template<typename T1> constexpr unsigned func_11c(const T1 x);
+
+void use_11(int *x) {
+  func_11(x);
+  func_11a(x, &x);
+  static_assert(func_11b(short(123)) == sizeof(short), "Invalid calculation");
+  static_assert(func_11b(123L) == sizeof(long), "Invalid calculation");
+  static_assert(func_11c(short(123)) == sizeof(int), "Invalid calculation");
+  static_assert(func_11c(123L) == sizeof(int), "Invalid calculation");
+}
+
+// void func_11<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_11IiEvPT_
+//
+// void func_11a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_11aIiPiEvPT_PT0_
+
+
+template<typename T>
+struct C12 {
+  template<typename T1> friend void func_12(T1 *x) { T var; }
+  template<typename T1, typename T2> friend void func_12a(T1 *x, T2 *y) { T var; }
+};
+
+template<typename T> void func_12(T *x);
+template<typename T1, typename T2> void func_12a(T1 *x, T2 *y);
+
+void use_12(int *x) {
+  func_12(x);
+  func_12a(x, &x);
+}
+
+C12<int> v12;
+
+// void func_12<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_12IiEvPT_
+//
+// void func_12a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_12aIiPiEvPT_PT0_
+
+
+template<typename T1> void func_13(T1 *x);
+template<typename T1, typename T2> void func_13a(T1 *x, T2 *y);
+
+template<typename T>
+struct C13 {
+  template<typename T1> friend void func_13(T1 *x) { T var; }
+  template<typename T1, typename T2> friend void func_13a(T1 *x, T2 *y) { T var; }
+};
+
+void use_13(int *x) {
+  func_13(x);
+  func_13a(x, &x);
+}
+
+C13<int> v13;
+
+// void func_13<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_13IiEvPT_
+//
+// void func_13a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_13aIiPiEvPT_PT0_
+
+
+template<typename T1> void func_14(T1 *x);
+template<typename T1, typename T2> void func_14a(T1 *x, T2 *y);
+
+void use_14(int *x) {
+  func_14(x);
+  func_14a(x, &x);
+}
+
+template<typename T>
+struct C14 {
+  template<typename T1> friend void func_14(T1 *x) { T var; }
+  template<typename T1, typename T2> friend void func_14a(T1 *x, T2 *y) { T var; }
+};
+
+C14<int> v14;
+
+// void func_14<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_14IiEvPT_
+//
+// void func_14a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_14aIiPiEvPT_PT0_
+
+
+template<typename T>
+struct C15 {
+  template<typename T1> friend void func_15(T1 *x) { T var; }
+  template<typename T1, typename T2> friend void func_15a(T1 *x, T2 *y) { T var; }
+  template<typename T1> friend constexpr unsigned func_15b(const T1 x) { return sizeof(T1); }
+  template<typename T1> friend constexpr unsigned func_15c(const T1 x) { return sizeof(T); }
+};
+
+template<typename T1> void func_15(T1 *x);
+template<typename T1, typename T2> void func_15a(T1 *x, T2 *y);
+template<typename T1> constexpr unsigned func_15b(const T1 x);
+template<typename T1> constexpr unsigned func_15c(const T1 x);
+
+C15<int> v15;
+
+void use_15(int *x) {
+  func_15(x);
+  func_15a(x, &x);
+  static_assert(func_15b(short(122)) == sizeof(short), "Invalid calculation");
+  static_assert(func_15b(122L) == sizeof(long), "Invalid calculation");
+  static_assert(func_15c(short(122)) == sizeof(int), "Invalid calculation");
+  static_assert(func_15c(122L) == sizeof(int), "Invalid calculation");
+}
+
+// void func_15<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_15IiEvPT_
+//
+// void func_15a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_15aIiPiEvPT_PT0_
+
+
+// File level declaration, friend pattern and declaration.
+
+
+template<typename T1> void func_16(T1 *x);
+template<typename T1, typename T2> void func_16a(T1 *x, T2 *y);
+template<typename T1> constexpr unsigned func_16b(const T1 x);
+template<typename T1> constexpr unsigned func_16c(const T1 x);
+
+template<typename T>
+struct C16a {
+  template<typename T1> friend void func_16(T1 *x) { T var; }
+  template<typename T1, typename T2> friend void func_16a(T1 *x, T2 *y) { T var; }
+  template<typename T1> friend constexpr unsigned func_16b(const T1 x) { return sizeof(T1); }
+  template<typename T1> friend constexpr unsigned func_16c(const T1 x) { return sizeof(T); }
+};
+
+C16a<int> v16a;
+
+template<typename T>
+struct C16b {
+  template<typename T1> friend void func_16(T1 *x);
+  template<typename T1, typename T2> friend void func_16a(T1 *x, T2 *y);
+  template<typename T1> friend constexpr unsigned func_16b(const T1 x);
+  template<typename T1> friend constexpr unsigned func_16c(const T1 x);
+};
+
+C16b<int> v16b;
+
+void use_16(int *x) {
+  func_16(x);
+  func_16a(x, &x);
+  static_assert(func_16b(short(122)) == sizeof(short), "Invalid calculation");
+  static_assert(func_16b(122L) == sizeof(long), "Invalid calculation");
+  static_assert(func_16c(short(122)) == sizeof(int), "Invalid calculation");
+  static_assert(func_16c(122L) == sizeof(int), "Invalid calculation");
+}
+
+// void func_16<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_16IiEvPT_
+//
+// void func_16a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_16aIiPiEvPT_PT0_
+
+
+template<typename T1> void func_17(T1 *x);
+template<typename T1, typename T2> void func_17a(T1 *x, T2 *y);
+
+template<typename T>
+struct C17b {
+  template<typename T1> friend void func_17(T1 *x);
+  template<typename T1, typename T2> friend void func_17a(T1 *x, T2 *y);
+};
+
+C17b<int> v17b;
+
+void use_17(int *x) {
+  func_17(x);
+  func_17a(x, &x);
+}
+
+template<typename T>
+struct C17a {
+  template<typename T1> friend void func_17(T1 *x) { T var; }
+  template<typename T1, typename T2> friend void func_17a(T1 *x, T2 *y) { T var; }
+};
+
+C17a<int> v17a;
+
+// void func_17<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_17IiEvPT_
+//
+// void func_17a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_17aIiPiEvPT_PT0_
+
+
+template<typename T1> void func_18(T1 *x);
+template<typename T1, typename T2> void func_18a(T1 *x, T2 *y);
+template<typename T1> constexpr unsigned func_18b(const T1 x);
+template<typename T1> constexpr unsigned func_18c(const T1 x);
+
+template<typename T>
+struct C18b {
+  template<typename T1> friend void func_18(T1 *x);
+  template<typename T1, typename T2> friend void func_18a(T1 *x, T2 *y);
+  template<typename T1> friend constexpr unsigned func_18b(const T1 x);
+  template<typename T1> friend constexpr unsigned func_18c(const T1 x);
+  struct Inner {
+    template<typename T1> friend void func_18(T1 *x) { T var; }
+    template<typename T1, typename T2> friend void func_18a(T1 *x, T2 *y) { T var; }
+    template<typename T1> friend constexpr unsigned func_18b(const T1 x) { return sizeof(T1); }
+    template<typename T1> friend constexpr unsigned func_18c(const T1 x) { return sizeof(T); }
+  };
+};
+
+C18b<int>::Inner v18b;
+
+void use_18(int *x) {
+  func_18(x);
+  func_18a(x, &x);
+  static_assert(func_18b(short(122)) == sizeof(short), "Invalid calculation");
+  static_assert(func_18b(122L) == sizeof(long), "Invalid calculation");
+  static_assert(func_18c(short(122)) == sizeof(int), "Invalid calculation");
+  static_assert(func_18c(122L) == sizeof(int), "Invalid calculation");
+}
+
+// void func_18<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_18IiEvPT_
+//
+// void func_18a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_18aIiPiEvPT_PT0_
+
+
+template<typename T1> void func_19(T1 *x);
+template<typename T1, typename T2> void func_19a(T1 *x, T2 *y);
+template<typename T1> constexpr unsigned func_19b(const T1 x);
+template<typename T1> constexpr unsigned func_19c(const T1 x);
+
+template<typename T>
+struct C19b {
+  struct Inner {
+    template<typename T1> friend void func_19(T1 *x) { T var; }
+    template<typename T1, typename T2> friend void func_19a(T1 *x, T2 *y) { T var; }
+    template<typename T1> friend constexpr unsigned func_19b(const T1 x) { return sizeof(T1); }
+    template<typename T1> friend constexpr unsigned func_19c(const T1 x) { return sizeof(T); }
+  };
+  template<typename T1> friend void func_19(T1 *x);
+  template<typename T1, typename T2> friend void func_19a(T1 *x, T2 *y);
+  template<typename T1> friend constexpr unsigned func_19b(const T1 x);
+  template<typename T1> friend constexpr unsigned func_19c(const T1 x);
+};
+
+C19b<int>::Inner v19b;
+
+void use_19(int *x) {
+  func_19(x);
+  func_19a(x, &x);
+  static_assert(func_19b(short(122)) == sizeof(short), "Invalid calculation");
+  static_assert(func_19b(122L) == sizeof(long), "Invalid calculation");
+  static_assert(func_19c(short(122)) == sizeof(int), "Invalid calculation");
+  static_assert(func_19c(122L) == sizeof(int), "Invalid calculation");
+}
+
+// void func_19<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_19IiEvPT_
+//
+// void func_19a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_19aIiPiEvPT_PT0_
+
+
+template<typename T1> void func_20(T1 *x);
+template<typename T1, typename T2> void func_20a(T1 *x, T2 *y);
+template<typename T1> constexpr unsigned func_20b(const T1 x);
+template<typename T1> constexpr unsigned func_20c(const T1 x);
+
+template<typename T>
+struct C20b {
+  struct Inner {
+    template<typename T1> friend void func_20(T1 *x);
+    template<typename T1, typename T2> friend void func_20a(T1 *x, T2 *y);
+    template<typename T1> friend constexpr unsigned func_20b(const T1 x);
+    template<typename T1> friend constexpr unsigned func_20c(const T1 x);
+  };
+  template<typename T1> friend void func_20(T1 *x) { T var; }
+  template<typename T1, typename T2> friend void func_20a(T1 *x, T2 *y) { T var; }
+  template<typename T1> friend constexpr unsigned func_20b(const T1 x) { return sizeof(T1); }
+  template<typename T1> friend constexpr unsigned func_20c(const T1 x) { return sizeof(T); }
+};
+
+C20b<int>::Inner v20b;
+
+void use_20(int *x) {
+  func_20(x);
+  func_20a(x, &x);
+  static_assert(func_20b(short(122)) == sizeof(short), "Invalid calculation");
+  static_assert(func_20b(122L) == sizeof(long), "Invalid calculation");
+  static_assert(func_20c(short(122)) == sizeof(int), "Invalid calculation");
+  static_assert(func_20c(122L) == sizeof(int), "Invalid calculation");
+}
+
+// void func_20<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_20IiEvPT_
+//
+// void func_20a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_20aIiPiEvPT_PT0_
+
+
+template<typename T1> void func_21(T1 *x);
+template<typename T1, typename T2> void func_21a(T1 *x, T2 *y);
+template<typename T1> constexpr unsigned func_21b(const T1 x);
+template<typename T1> constexpr unsigned func_21c(const T1 x);
+
+template<typename T>
+struct C21b {
+  template<typename T1> friend void func_21(T1 *x) { T var; }
+  template<typename T1, typename T2> friend void func_21a(T1 *x, T2 *y) { T var; }
+  template<typename T1> friend constexpr unsigned func_21b(const T1 x) { return sizeof(T1); }
+  template<typename T1> friend constexpr unsigned func_21c(const T1 x) { return sizeof(T); }
+  struct Inner {
+    template<typename T1> friend void func_21(T1 *x);
+    template<typename T1, typename T2> friend void func_21a(T1 *x, T2 *y);
+    template<typename T1> friend constexpr unsigned func_21b(const T1 x);
+    template<typename T1> friend constexpr unsigned func_21c(const T1 x);
+  };
+};
+
+C21b<int> v21b;
+
+void use_21(int *x) {
+  func_21(x);
+  func_21a(x, &x);
+  static_assert(func_21b(short(122)) == sizeof(short), "Invalid calculation");
+  static_assert(func_21b(122L) == sizeof(long), "Invalid calculation");
+  static_assert(func_21c(short(122)) == sizeof(int), "Invalid calculation");
+  static_assert(func_21c(122L) == sizeof(int), "Invalid calculation");
+}
+
+// void func_21<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_21IiEvPT_
+//
+// void func_21a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_21aIiPiEvPT_PT0_
+
+
+template<typename T1> void func_22(T1 *x);
+template<typename T1, typename T2> void func_22a(T1 *x, T2 *y);
+template<typename T1> constexpr unsigned func_22b(const T1 x);
+template<typename T1> constexpr unsigned func_22c(const T1 x);
+template<typename T1> constexpr unsigned func_22d(const T1 x);
+
+template<typename T>
+struct C22b {
+  template<typename T1> friend void func_22(T1 *x);
+  template<typename T1, typename T2> friend void func_22a(T1 *x, T2 *y);
+  template<typename T1> friend constexpr unsigned func_22b(const T1 x);
+  template<typename T1> friend constexpr unsigned func_22c(const T1 x);
+  template<typename T1> friend constexpr unsigned func_22d(const T1 x);
+  template<typename TT>
+  struct Inner {
+    template<typename T1> friend void func_22(T1 *x) { T var; }
+    template<typename T1, typename T2> friend void func_22a(T1 *x, T2 *y) { T var; }
+    template<typename T1> friend constexpr unsigned func_22b(const T1 x) { return sizeof(T1); }
+    template<typename T1> friend constexpr unsigned func_22c(const T1 x) { return sizeof(T); }
+    template<typename T1> friend constexpr unsigned func_22d(const T1 x) { return sizeof(TT); }
+  };
+};
+
+C22b<int>::Inner<char> v22b;
+
+void use_22(int *x) {
+  func_22(x);
+  func_22a(x, &x);
+  static_assert(func_22b(short(122)) == sizeof(short), "Invalid calculation");
+  static_assert(func_22b(122L) == sizeof(long), "Invalid calculation");
+  static_assert(func_22c(short(122)) == sizeof(int), "Invalid calculation");
+  static_assert(func_22c(122L) == sizeof(int), "Invalid calculation");
+  static_assert(func_22d(short(122)) == sizeof(char), "Invalid calculation");
+  static_assert(func_22d(122L) == sizeof(char), "Invalid calculation");
+}
+
+// void func_22<int>(int*)
+// CHECK: define linkonce_odr void @_Z7func_22IiEvPT_
+//
+// void func_22a<int, int*>(int*, int**)
+// CHECK: define linkonce_odr void @_Z8func_22aIiPiEvPT_PT0_
+
+
+namespace pr26512 {
+struct A {
+  template <class, bool> class B {
+    template <class r_colony_allocator_type, bool r_is_const,
+              class distance_type>
+    friend void advance(B<r_colony_allocator_type, r_is_const> &,
+                        distance_type);
+  };
+  template <class r_colony_allocator_type, bool r_is_const, class distance_type>
+  friend void advance(B<r_colony_allocator_type, r_is_const> &, distance_type) {
+    distance_type a;
+  }
+};
+void main() {
+  A::B<int, false> b;
+  advance(b, 0);
+}
+}
+
+// void pr26512::advance<int, false, int>(pr26512::A::B<int, false>&, int)
+// CHECK: define linkonce_odr void @_ZN7pr265127advanceIiLb0EiEEvRNS_1A1BIT_XT0_EEET1_
+
+
+namespace pr19095 {
+template <class T> void f(T);
+
+template <class U> class C {
+  template <class T> friend void f(T) {
+     C<U> c;
+     c.i = 3;
+  }
+
+public:
+  void g() {
+    f(3.0);
+  }
+  int i;
+};
+
+void main () {
+  f(7);
+  C<double> c;
+  c.g();
+}
+}
+
+// void pr19095::f<double>(double)
+// CHECK: define linkonce_odr void @_ZN7pr190951fIdEEvT_
+
+
+namespace pr34343 {
+template <typename... e> struct f;
+template <typename> struct g {
+  template <typename... h>
+  friend bool operator==(const g<h...> &, const g<h...> &) noexcept(f<h...>::k);
+};
+template <typename... e>
+bool operator==(const g<e...> &, const g<e...> &) noexcept(f<e...>::k);
+void l(g<int>) {}
+}
+