clang: perform deduction at the right depth on Sema::AddMethodTemplateCandidate

[mizvekov]

Summary

Fixes PR28087.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

.

[mizvekov]

rebase

[shafik]

clang/lib/Sema/SemaOverload.cpp

14123

Do we have a test for this case?

[mizvekov]

clang/lib/Sema/SemaOverload.cpp

14123

The test included hits it, but after a second look I realized this wasn't supposed to happen in the first place.
We are missing something else to make this fully work, I think we are not expanding across that nested function template.

Test case: https://godbolt.org/z/qq4rTfK9x

template <class...> struct S {
  template <int> auto f(decltype([](int...) {}()));
};
template struct S<>;

GCC compiles this, clang doesn't, because it thinks that lambda has 1 parameter.

I will take this patch out for changes, I probably won't have time to go back to it anytime soon because I have other patches with more priority.

clang/lib/Sema/SemaOverload.cpp

void Sema::AddMethodTemplateCandidate(
   //   In each case where a candidate is a function template, candidate
   //   function template specializations are generated using template argument
   //   deduction (14.8.3, 14.8.2). Those candidates are then handled as
   //   candidate functions in the usual way.113) A given name can refer to one
   //   or more function templates and also to a set of overloaded non-template
   //   functions. In such a case, the candidate functions generated from each
   //   function template are combined with the set of non-template candidate
   //   functions.
-  TemplateDeductionInfo Info(CandidateSet.getLocation());
+  TemplateDeductionInfo Info(CandidateSet.getLocation(),
+                             MethodTmpl->getTemplateParameters()->getDepth());
   FunctionDecl *Specialization = nullptr;
   ConversionSequenceList Conversions;
   if (TemplateDeductionResult Result = DeduceTemplateArguments(
           MethodTmpl, ExplicitTemplateArgs, Args, Specialization, Info,
           PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
             return CheckNonDependentConversions(
                 MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
                 SuppressUserConversions, ActingContext, ObjectType,
if (i < Args.size()) {
       Arg = Args[i];
       ExprResult InputInit =
           S.PerformCopyInitialization(InitializedEntity::InitializeParameter(
                                           S.Context, Method->getParamDecl(i)),
                                       SourceLocation(), Arg);
       IsError |= InputInit.isInvalid();
       Arg = InputInit.getAs<Expr>();
     } else {
-      ExprResult DefArg =
-          S.BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i));
+      ParmVarDecl *Param = Method->getParamDecl(i);
+      if (!Param->hasDefaultArg()) {
+        IsError = true;
+        break;
+      }
+      ExprResult DefArg = S.BuildCXXDefaultArgExpr(LParenLoc, Method, Param);
       if (DefArg.isInvalid()) {
         IsError = true;
         break;
       }
       Arg = DefArg.getAs<Expr>();
     }
 
     MethodArgs.push_back(Arg);

clang/test/CXX/temp/temp.decls/temp.variadic/p5-cxx20.cpp

+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
+// expected-no-diagnostics
+
+namespace pr28087 {
+template <typename F> auto apply(F f) { f(); }
+template <class...> struct S {
+  template <int> auto f(decltype(apply([](auto...) {})));
+};
+template struct S<>;
+} // namespace pr28087