[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 ↗

(On Diff #516152)

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 ↗

(On Diff #516152)

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 ↗

(On Diff #516152)

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

[HerrCai0907]

clang/lib/Sema/SemaTemplateDeduction.cpp

3598 ↗

(On Diff #516152)

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 ↗

(On Diff #516152)

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 ↗

(On Diff #516152)

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 ↗

(On Diff #516152)

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 ↗

(On Diff #516152)

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 ↗

(On Diff #516152)

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 ↗

(On Diff #516152)

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 ↗

(On Diff #516152)

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/SemaTemplateInstantiateDecl.cpp

 /// Normal class members are of more specific types and therefore
 /// don't make it here.  This function serves three purposes:
 ///   1) instantiating function templates
 ///   2) substituting friend and local function declarations
 ///   3) substituting deduction guide declarations for nested class templates
 Decl *TemplateDeclInstantiator::VisitFunctionDecl(
     FunctionDecl *D, TemplateParameterList *TemplateParams,
     RewriteKind FunctionRewriteKind) {
+  const FunctionDecl *Definition = D;
+  D->isDefined(Definition, true);
+    
   // Check whether there is already a function template specialization for
   // this declaration.
-  FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
+  FunctionTemplateDecl *FunctionTemplate = Definition->getDescribedFunctionTemplate();
   if (FunctionTemplate && !TemplateParams) {
     ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
 
     void *InsertPos = nullptr;
     FunctionDecl *SpecFunc
       = FunctionTemplate->findSpecialization(Innermost, InsertPos);
 
     // If we already have a function template specialization, return it.
Decl *TemplateDeclInstantiator::VisitFunctionDecl(
 
   if (D->isLocalExternDecl())
     Function->setLocalExternDecl();
 
   DeclContext *LexicalDC = Owner;
   if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) {
     assert(D->getDeclContext()->isFileContext());
     LexicalDC = D->getDeclContext();
-  }
-  else if (D->isLocalExternDecl()) {
+  } else if (D->isLocalExternDecl()) {
     LexicalDC = SemaRef.CurContext;
+  } else if (isFriend && Definition != D) {
+    LexicalDC = const_cast<DeclContext *>(Definition->getLexicalDeclContext());
   }
-
   Function->setLexicalDeclContext(LexicalDC);
 
   // Attach the parameters
   for (unsigned P = 0; P < Params.size(); ++P)
     if (Params[P])
       Params[P]->setOwningFunction(Function);
   Function->setParams(Params);
 

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

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