[Clang] Fix filtering of inline namespaces for friend functions

[shafik]

Summary

PR D135370 implemented a performance improvement but it restricted the filtering of declaration from inline namespace too much. In particular it did not filter for the function template case.

This led to a regression and this PR removes that check.

This fixes: https://github.com/llvm/llvm-project/issues/61851

[aaron.ballman]

Good catch! Let's skip the release note for this for now, because I think we should cherry-pick this to the 16.0.2 milestone -- but you should add the release note when landing on that branch so users know about the fix.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (DependentFunctionTemplateSpecializationInfo *Info
     // tag type. Note that this does not apply if we're declaring a
     // typedef (C++ [dcl.typedef]p4).
     if (Previous.isSingleTagDecl())
       Previous.clear();
 
     // Filter out previous declarations that don't match the scope. The only
     // effect this has is to remove declarations found in inline namespaces
     // for friend declarations with unqualified names.
-    if (isFriend && !QualifierLoc && !FunctionTemplate) {
+    if (isFriend && !QualifierLoc) {
       SemaRef.FilterLookupForScope(Previous, DC, /*Scope=*/ nullptr,
                                    /*ConsiderLinkage=*/ true,
                                    QualifierLoc.hasQualifier());
     }
   }
 
   // Per [temp.inst], default arguments in function declarations at local scope
   // are instantiated along with the enclosing declaration. For example:

clang/test/SemaTemplate/friend.cpp

 }
 
 namespace PR42513_comment3 {
   template<typename X> struct T { friend auto f(X*) { return nullptr; } };
   struct X1 { friend auto f(X1*); };
   template struct T<X1>;
   int n = f((X1*)nullptr); // expected-error {{cannot initialize a variable of type 'int' with an rvalue of type 'std::nullptr_t'}}
 }
+
+namespace GH61851 {
+namespace A {
+inline namespace B {
+  inline constexpr struct {} foo;
+}
+
+template <typename T>
+class Bar {
+  template <typename U>
+  friend void foo(U &&arg) {} // no diagnostic expected
+};
+}
+
+void foobar() {
+  A::Bar<int> b;
+}
+}