[Sema] ADL: Template arguments in a template-id naming a set of overloaded functions (part of CWG 997)

[riccibruno]

Summary

CWG 997 added the following wording at the end of [basic.lookup.argdep]p2

[...] Additionally, if the aforementioned set of overloaded functions is named with a template-id, its associated classes and namespaces are those of its type template-arguments and its template template-arguments.

This resolve CWG 1015 and part of CWG 997 (I will mark it as done when the rest of it is implemented).

[riccibruno]

For information we are discussing in D60570 whether it is actually a good idea to implement this rule.

[riccibruno]

@rsmith Do you have an opinion on whether this ADL rule should be implemented ?

lib/Sema/SemaLookup.cpp

for (const auto &Base : Class->bases()) {
         // Make sure we visit the bases of this base class.
         if (BaseDecl->bases_begin() != BaseDecl->bases_end())
           Bases.push_back(BaseDecl);
       }
     }
   }
 }
 
-// Add the associated classes and namespaces for
-// argument-dependent lookup with an argument of type T
-// (C++ [basic.lookup.koenig]p2).
+// Add the associated classes and namespaces for argument-dependent
+// lookup with an argument of type T (C++ [basic.lookup.argdep]p2).
 static void
 addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType Ty) {
-  // C++ [basic.lookup.koenig]p2:
+  // C++ [basic.lookup.argdep]p2:
   //
   //   For each argument type T in the function call, there is a set
   //   of zero or more associated namespaces and a set of zero or more
   //   associated classes to be considered. The sets of namespaces and
   //   classes is determined entirely by the types of the function
   //   arguments (and the namespace of any template template
   //   argument). Typedef names and using-declarations used to specify
   //   the types do not contribute to this set. The sets of namespaces
void Sema::FindAssociatedClassesAndNamespaces(
     AssociatedNamespaceSet &AssociatedNamespaces,
     AssociatedClassSet &AssociatedClasses) {
   AssociatedNamespaces.clear();
   AssociatedClasses.clear();
 
   AssociatedLookup Result(*this, InstantiationLoc,
                           AssociatedNamespaces, AssociatedClasses);
 
-  // C++ [basic.lookup.koenig]p2:
+  // C++ [basic.lookup.argdep]p2:
   //   For each argument type T in the function call, there is a set
   //   of zero or more associated namespaces and a set of zero or more
   //   associated classes to be considered. The sets of namespaces and
   //   classes is determined entirely by the types of the function
   //   arguments (and the namespace of any template template
   //   argument).
   for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
     Expr *Arg = Args[ArgIdx];
 
     if (Arg->getType() != Context.OverloadTy) {
       addAssociatedClassesAndNamespaces(Result, Arg->getType());
       continue;
     }
 
-    // [...] In addition, if the argument is the name or address of a
-    // set of overloaded functions and/or function templates, its
-    // associated classes and namespaces are the union of those
-    // associated with each of the members of the set: the namespace
-    // in which the function or function template is defined and the
-    // classes and namespaces associated with its (non-dependent)
-    // parameter types and return type.
     OverloadExpr *OE = OverloadExpr::find(Arg).Expression;
 
+    // C++ [basic.lookup.argdep] end of p2:
+    //   [...] In addition, if the argument is the name or address of a set of
+    //   overloaded functions and/or function templates, its associated classes
+    //   and namespaces are the union of those associated with each of the
+    //   members of the set, i.e., the classes and namespaces associated with
+    //   its parameter types and return type.
+    //
+    // TODO: CWG 997 removed the restriction on non-dependent types.
     for (const NamedDecl *D : OE->decls()) {
       // Look through any using declarations to find the underlying function.
       const FunctionDecl *FDecl = D->getUnderlyingDecl()->getAsFunction();
 
       // Add the classes and namespaces associated with the parameter
       // types and return type of this function.
       addAssociatedClassesAndNamespaces(Result, FDecl->getType());
     }
+
+    //   [...] Additionally, if the aforementioned set of overloaded functions
+    //   is named with a template-id, its associated classes and namespaces also
+    //   include those of its type template-arguments and its template
+    //   template-arguments.
+    //
+    // Added by CWG 997.
+    for (const TemplateArgumentLoc &TemplateArgLoc : OE->template_arguments()) {
+      const TemplateArgument &TemplateArg = TemplateArgLoc.getArgument();
+      addAssociatedClassesAndNamespaces(Result, TemplateArg);
+    }
   }
 }
 
 NamedDecl *Sema::LookupSingleName(Scope *S, DeclarationName Name,
                                   SourceLocation Loc,
                                   LookupNameKind NameKind,
                                   RedeclarationKind Redecl) {
   LookupResult R(*this, Name, Loc, NameKind, Redecl);

test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-associated-namespaces-classes.cpp

 // with a template-id, its associated classes and namespaces also include
 // those of its type template-arguments and its template template-arguments.
 //
 // CWG 33 for the union rule. CWG 997 for the template-id rule.
 namespace adl_overload_set {
   namespace N {
     struct S {};
     constexpr int f(int (*g)()) { return g(); }
-    // expected-note@-1 2{{'N::f' declared here}}
+    // expected-note@-1 {{'N::f' declared here}}
     template <typename T> struct Q;
   }
 
   constexpr int g1() { return 1; }
   constexpr int g1(N::S) { return 2; }
 
   template <typename T> constexpr int g2() { return 3; }
 
   // Inspired from CWG 997.
   constexpr int g3() { return 4; }
   template <typename T> constexpr int g3(T, N::Q<T>) { return 5; }
 
+  template <template <typename> class Z> constexpr int g4() { return 6; }
+
   void test() {
-    static_assert(f(g1) == 1, "");        // Well-formed from the union rule above
-    static_assert(f(g2<N::S>) == 3, "");  // FIXME: Well-formed from the template-id rule above.
-                                          // expected-error@-1 {{use of undeclared}}
+    static_assert(f(g1) == 1, "");        // Well-formed from the union rule.
+    static_assert(f(g2<N::S>) == 3, "");  // Well-formed from the template-id rule.
     static_assert(f(g3) == 4, "");        // FIXME: Also well-formed from the union rule.
                                           // expected-error@-1 {{use of undeclared}}
+    static_assert(f(g4<N::Q>) == 6, "");  // Well-formed from the template-id rule.
   }
 }

test/CXX/drs/dr10xx.cpp

namespace dr1004 { // dr1004: 5
   };
 
   // This example (from the standard) is actually ill-formed, because
   // name lookup of "T::template A" names the constructor.
   template<class T, template<class> class U = T::template A> struct Third { }; // expected-error {{is a constructor name}}
   Third<A<int> > t; // expected-note {{in instantiation of default argument}}
 }
 
+namespace dr1015 { // dr1015: 9
+  namespace N {
+    struct S {};
+    void f(void (*)(S));
+  }
+
+  template<typename T> void g(T);
+
+  void h() {
+    f(g<N::S>); // ok, N::f
+  }
+}
+
 namespace dr1048 { // dr1048: 3.6
   struct A {};
   const A f();
   A g();
   typedef const A CA;
 #if __cplusplus >= 201103L
   // ok: we deduce non-const A in each case.
   A &&a = [] (int n) {