[Clang] Modify Parser::ParseLambdaExpressionAfterIntroducer to check whether the lambda-declarator is valid

[shafik]

Summary

We had a couple of crashes due to invalid lambda trailing return types that were diagnosed but not treated as errors during parsing. So now in Parser::ParseLambdaExpressionAfterIntroducer(...) after ActOnStartOfLambdaDefinition(...) we also check if the lambda-declarator is invalid and if so we end up in ActOnLambdaError(...).

Fixes: https://github.com/llvm/llvm-project/issues/64962
https://github.com/llvm/llvm-project/issues/28679

[cor3ntin]

LGTM modulo:

• No release notes
• I think you need to write in the commit

Fixes  https://github.com/llvm/llvm-project/issues/64962
Fixes https://github.com/llvm/llvm-project/issues/28679

for github not to be confused

• You need to clang-format

clang/test/Parser/cxx0x-lambda-expressions.cpp

2 ↗

(On Diff #553342)

We might want to put that test in clang/test/Parser/cxx2a-template-lambdas.cpp instead

[shafik]

• Move test to C++20 file
• Apply clang-format

[cor3ntin]

Still missing a release note.

[shafik]

• Add release notes

[cor3ntin]

Thanks!

clang/docs/ReleaseNotes.rst

- Expressions producing ``nullptr`` are correctly evaluated
   by the constant interpreter when appearing as the operand
   of a binary comparison.
   (`#64923 <https://github.com/llvm/llvm-project/issues/64923>`_)
 
 - Fix a crash when an immediate invocation is not a constant expression
   and appear in an implicit cast.
   (`#64949 <https://github.com/llvm/llvm-project/issues/64949>`_).
 
+- Fix crash when parsing ill-formed lambda trailing return type. Fixes:
+  (`#64962 <https://github.com/llvm/llvm-project/issues/64962>`_) and
+  (`#28679 <https://github.com/llvm/llvm-project/issues/28679>`_).
+
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 - Fixed an import failure of recursive friend class template.
   `Issue 64169 <https://github.com/llvm/llvm-project/issues/64169>`_
 - Remove unnecessary RecordLayout computation when importing UnaryOperator. The
   computed RecordLayout is incorrect if fields are not completely imported and
   should not be cached.
   `Issue 64170 <https://github.com/llvm/llvm-project/issues/64170>`_

clang/lib/Parse/ParseExprCXX.cpp

if (!Tok.is(tok::l_brace)) {
     return ExprError();
   }
 
   StmtResult Stmt(ParseCompoundStatementBody());
   BodyScope.Exit();
   TemplateParamScope.Exit();
   LambdaScope.Exit();
 
-  if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid())
+  if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid() &&
+      !D.isInvalidType())
     return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope());
 
   Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
   return ExprError();
 }
 
 /// ParseCXXCasts - This handles the various ways to cast expressions to another
 /// type.

clang/test/Parser/cxx2a-template-lambdas.cpp

 auto L14 = []<auto> requires true() noexcept requires true {};
 
 auto XL0 = []<auto> noexcept requires true {};               // expected-error {{expected body of lambda expression}}
 auto XL1 = []<auto> requires true noexcept requires true {}; // expected-error {{expected body}}
 #if __cplusplus <= 202002L
 // expected-warning@-3 {{is a C++23 extension}}
 // expected-warning@-3 {{is a C++23 extension}}
 #endif
+
+namespace GH64962 {
+void f() {
+  [] <typename T>(T i) -> int[] // expected-error {{function cannot return array type 'int[]'}}
+                                // extension-warning {{explicit template parameter list for lambdas is a C++20 extension}}
+    { return 3; } (v); // expected-error {{use of undeclared identifier 'v'}}
+}
+}

clang/test/SemaCXX/subst-func-type-invalid-ret-type.cpp

 // RUN: %clang -fsyntax-only -std=c++17 %s -Xclang -verify
 
 // The important part is that we do not crash.
 
 template<typename T> T declval();
 
 template <typename T>
-auto Call(T x) -> decltype(declval<T>()(0)) {} // expected-note{{candidate template ignored}}
+auto Call(T x) -> decltype(declval<T>()(0)) {}
 
 class Status {};
 
 void fun() {
   // The Status() (instead of Status) here used to cause a crash.
   Call([](auto x) -> Status() {}); // expected-error{{function cannot return function type 'Status ()}}
-  // expected-error@-1{{no matching function for call to 'Call'}}
 }