[C++20] Mark lambdas in lambda specifiers as dependent if necessary

[lime]

Summary

Lambdas in lambda specifiers should be dependent if they appear in a generic
lambda, while current lambda creating processes fail to specify the correct
dependency kind to them.

This patch adds a template parameter scope before parsing lambda specifiers and
fixes issues:
https://github.com/llvm/llvm-project/issues/57155
https://github.com/llvm/llvm-project/issues/57170

[lime]

I submitted it a little early. The correct fix may be letting the declaration be dependent.

[lime]

There should be a more general solution. This patch does not solve the issue here.

[cor3ntin]

clang/test/SemaCXX/lambda-unevaluated.cpp

127

I thought unevaluated lambdas could not have captures. that might be the issue here

[shafik]

clang/test/SemaCXX/lambda-unevaluated.cpp

127

P0315 and says it should be allowed.

[lime]

Crashes were gone although via avoiding diagnostics directly in D140838. Considering this does not fix the acceptance of the ill code here, should I abandon this patch?

clang/lib/Parse/ParseExprCXX.cpp

if (Tok.isNot(tok::r_paren)) {
       // have already been incremented. So we make sure that at most a single
       // depth level is added.
       if (Actions.getCurGenericLambda())
         CurTemplateDepthTracker.setAddedDepth(1);
     }
 
     T.consumeClose();
 
+    MultiParseScope ScopeForGenericLambda(*this);
+    if (Actions.getCurGenericLambda())
+      ScopeForGenericLambda.Enter(Scope::TemplateParamScope);
     // Parse lambda-specifiers.
     ParseLambdaSpecifiers(LParenLoc, /*DeclEndLoc=*/T.getCloseLocation(),
                           ParamInfo, EllipsisLoc);
 
     // Parse requires-clause[opt].
     if (Tok.is(tok::kw_requires))
       ParseTrailingRequiresClause(D);
   } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,

clang/test/SemaCXX/lambda-unevaluated.cpp

 } // namespace GH51414
 
 namespace GH51641 {
 template <class T>
 void foo(decltype(+[](T) {}) lambda, T param);
 static_assert(!__is_same(decltype(foo<int>), void));
 } // namespace GH51641
 
+namespace GH57155 {
+auto foo(int t) {
+  int(*f)(int) = [](auto t) -> decltype([=] { return t; } ()) { return t; };
+  return f;
+}
+} // namespace GH57155
+
+namespace GH57170 {
+int(*f)(int) = [](auto t) -> decltype([] {
+    return 0;
+  } ()
+){
+  return t;
+};
+} // namespace GH57170
+
 namespace StaticLambdas {
 template <auto> struct Nothing {};
 Nothing<[]() static { return 0; }()> nothing;
 
 template <typename> struct NothingT {};
 Nothing<[]() static { return 0; }> nothingT;
 
 template <typename T>