generic lambda in tparam list is uncallable

[ericniebler]

Compile with -std=c++20:

template <auto A = [](auto x){}>
struct C {
  static constexpr auto B = A;
};

int main() {
  C<>::B(42);
}

result:

<source>:8:3: error: no matching function for call to object of type 'const (lambda at <source>:2:20)'
  C<>::B(42);
  ^~~~~~
<source>:2:20: note: candidate template ignored: couldn't infer template argument 'x:auto'
template <auto A = [](auto x){}>
                   ^
1 error generated.

I can't fathom why the compiler cannot infer the type of the lambda argument.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

[llvmbot]

@llvm/issue-subscribers-c-20

[Fznamznon]

Is this a valid code?
I'm not sure I understand what x should be. gcc agrees - https://godbolt.org/z/4TGbaToMj .

[shafik]

It seems potentially reasonable and MSVC accepts it: https://godbolt.org/z/E9dE588s8

gcc has the following bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=88313 and they have it as rejects valid.

CC @zygoloid any objection to calling this rejects valid?

[zygoloid]

This example looks valid to me.

[cor3ntin]

We seem to underflow template depth somewhere https://compiler-explorer.com/z/cnd9PcfcY

| |-FunctionTemplateDecl, col:48> col:20 operator()
| | |-TemplateTypeParmDecl <col:23, col:28> col:28 implicit class depth 32767 index 0 x:auto
| | `-CXXMethodDecl <col:48> col:20 constexpr operator() 'auto (auto) const -> int' inline```

[cor3ntin]

Investigating but ping @erichkeane in case he has an idea.

[erichkeane]

oh my! I don't have a really good idea, I'm guessing when we are instantiating 'C', we're improperly decrementing default-argument's lambda depth. I suspect since this is basically the first time we are allowing template parameters to be introduced in a default argument, we don't have anything that ensures its depth is increased. Though, I'm not sure what mechanism does that.

[cor3ntin]

oh my! I don't have a really good idea, I'm guessing when we are instantiating 'C', we're improperly decrementing default-argument's lambda depth. I suspect since this is basically the first time we are allowing template parameters to be introduced in a default argument, we don't have anything that ensures its depth is increased. Though, I'm not sure what mechanism does that.

I confirm this is the issue.
I got it to work by hacking around

llvm-project/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Line 2862 in 173855f

D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),

It should probably be TemplateArgs.getNumSubstitutedLevels() -1 when transforming the template parameter list of
a generic lambda, somehow