[Sema]Select correct lexical context during template instantiate

[HerrCai0907]

Summary

This patch wants to fix inline friend decl like

template <class F1> int foo(F1 X);
template <int A1> struct A {
  template <class F1> friend int foo(F1 X) { return A1; }
};

template struct A<1>;
int a = foo(1.0);

[HerrCai0907]

update

[HerrCai0907]

fix assert failed

[erichkeane]

clang/lib/Sema/SemaTemplateDeduction.cpp

3597

I was originally REALLY suspicious about this function call here (and the setup with the out parameter/2nd variable here). but it seems that the 'true' argument (which, needs a /*ParamName */ comment) is specifically designed for this situation.

3598

So in what case would the currently-instantiated definition NOT also be a friend? I would think this last condition should be able to be an assert instead.

3601

I THINK this should just be:
Owner = FD->getLexicalDeclContext() here.

[HerrCai0907]

clang/lib/Sema/SemaTemplateDeduction.cpp

3598

Last condition cannot be an assert, define and declare in difference place is common case, what we need to identifier in here is inlined friend define.

3601

The old Owner is FunctionTemplate->getLexicalDeclContext(). So I think we should use same level owner.

[HerrCai0907]

add comment and more test

[erichkeane]

clang/lib/Sema/SemaTemplateDeduction.cpp

3598

Can you be more clear here? WHEN can a definition and declaration NOT have the same friend object kind? THAT is probably incorrect a bug.

3601

Its not a question of "SameLevel", its that it was the accessible one based on what was around. IN this case, we have a 'better' alternative, which is the FunctionDecl.

[HerrCai0907]

clang/lib/Sema/SemaTemplateDeduction.cpp

3598

Sorry I cannot get the point.
Here I have 3 conditions:

1. FD->getFriendObjectKind() == Decl::FriendObjectKind::FOK_None

FD(declaration) is not friend object.

2. FD->isDefined(FDFriend, true)

get FDFriend(definition) from FD(declaration).

3. FDFriend->getFriendObjectKind() != Decl::FriendObjectKind::FOK_None)

FDFriend(definition) is friend object.

matching those 3 condition and then we can say FDFriend is a inline friend like

template <class F1> int foo(F1 X); // FD
template <int A1> struct A {
template <class F1> friend int foo(F1 X) { return A1; } // FDFriend
};

[HerrCai0907]

change LexicalDeclContext

[erichkeane]

clang/lib/Sema/SemaTemplateDeduction.cpp

3598

Ok, my question is: WHEN is #3 "false" but #1 and #2 are "true"? It should not be possible for #1 to be "true" but #3 to be "false", as far as I know.

[tahonermann]

clang/lib/Sema/SemaTemplateDeduction.cpp

3598

It looks like getFriendObjectKind() returns a declaration specific value such that, for the example given, it returns FOK_None for the first declaration and FOK_Declared for the friend definition. (I haven't tested that, but that is what my brief reading of the code suggests).

[erichkeane]

clang/lib/Sema/SemaTemplateDeduction.cpp

3598

Ah, right! thanks for that Tom! Yeah, its just that the 1st declaration is NOT a friend, I had these reversed in my head so was very confused. OK, thanks!

clang/lib/Sema/SemaTemplateDeduction.cpp

TemplateArgumentList *CanonicalDeducedArgumentList =
       TemplateArgumentList::CreateCopy(Context, CanonicalBuilder);
   Info.reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
 
   // Substitute the deduced template arguments into the function template
   // declaration to produce the function template specialization.
   DeclContext *Owner = FunctionTemplate->getDeclContext();
   if (FunctionTemplate->getFriendObjectKind())
     Owner = FunctionTemplate->getLexicalDeclContext();
+  FunctionDecl *FD = FunctionTemplate->getTemplatedDecl();
+  // additional check for inline friend, 
+  // ```
+  //   template <class F1> int foo(F1 X);
+  //   template <int A1> struct A {
+  //     template <class F1> friend int foo(F1 X) { return A1; }
+  //   };
+  //   template struct A<1>;
+  //   int a = foo(1.0);
+  // ```
+  const FunctionDecl *FDFriend;
+  if (FD->getFriendObjectKind() == Decl::FriendObjectKind::FOK_None &&
+      FD->isDefined(FDFriend, /*CheckForPendingFriendDefinition*/ true) &&
+      FDFriend->getFriendObjectKind() != Decl::FriendObjectKind::FOK_None) {
+    FD = const_cast<FunctionDecl *>(FDFriend);
+    Owner = FD->getLexicalDeclContext();
+  }
   MultiLevelTemplateArgumentList SubstArgs(
       FunctionTemplate, CanonicalDeducedArgumentList->asArray(),
       /*Final=*/false);
   Specialization = cast_or_null<FunctionDecl>(
-      SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, SubstArgs));
+      SubstDecl(FD, Owner, SubstArgs));
   if (!Specialization || Specialization->isInvalidDecl())
     return TDK_SubstitutionFailure;
 
   assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
          FunctionTemplate->getCanonicalDecl());
 
   // If the template argument list is owned by the function template
   // specialization, release it.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
   // specialization, which is not a SFINAE context, so that we diagnose any
   // further errors in the declaration itself.
   //
   // FIXME: This is a hack.
   typedef Sema::CodeSynthesisContext ActiveInstType;
   ActiveInstType &ActiveInst = SemaRef.CodeSynthesisContexts.back();
   if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
       ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
-    if (FunctionTemplateDecl *FunTmpl
-          = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) {
-      assert(FunTmpl->getTemplatedDecl() == Tmpl &&
-             "Deduction from the wrong function template?");
-      (void) FunTmpl;
+    if (isa<FunctionTemplateDecl>(ActiveInst.Entity)) {
       SemaRef.InstantiatingSpecializations.erase(
           {ActiveInst.Entity->getCanonicalDecl(), ActiveInst.Kind});
       atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef, ActiveInst);
       ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
       ActiveInst.Entity = New;
       atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, ActiveInst);
     }
   }

clang/test/SemaTemplate/template-friend-definition-in-template.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// expected-no-diagnostics
+
+template <class F1> int foo1(F1 X1);
+
+template <int A1> struct A {
+  template <class F2> friend int foo1(F2 X2) {
+    return A1;
+  }
+};
+
+template struct A<1>;
+int main() { 
+  foo1(1.0);
+}
+
+template <class F1> int foo2(F1 X1);
+
+template <int A1> struct B {
+  template <class F2> friend int foo2(F2 X2) {
+    return A1;
+  }
+};
+
+template struct B<1>;
+template int foo2<float>(float X1);