[clang] [C++2b] [P1102] Accept lambdas without parameter list ().

[curdeius]

Summary

As an extension, accept such lambdas in previous standards with a warning.

• http://eel.is/c++draft/expr.prim.lambda
• http://wg21.link/P1102

[curdeius]

Revert unintended changes.

[curdeius]

Is there something else that I should test?

clang/lib/Parse/ParseExprCXX.cpp

1434

I'm not sure what I should do with LParenLoc and RParenLoc. Any idea?

[aaron.ballman]

clang/lib/Parse/ParseExprCXX.cpp

1432–1433

No need to call this here, it happens from the destructor of ParseScope.

1432–1435

No need to call this here, it happens from the destructor of ParseScope.

1434

I don't know the answer to this, but... do we need a prototype scope at all when there's no parameter list? The old code was doing this, so I don't think this is an issue with your patch per se, more just curiosity whether this is necessary in this case.

1434

What you've done here seems reasonable to me. The SourceLocation for the parens will be invalid, which is the behavior I'd expect when the parens are missing.

clang/test/Parser/cxx2b-lambdas.cpp

23

It'd be handy to test: auto XL3 = []( constexpr mutable constexpr {}; where the parameter list is missing the closing right paren.

[curdeius]

• Add test.
• Remove unnecessary PrototypeScope.exit().

[curdeius]

Thank you for the review Aaron. I hope having addressed your comments so far.
I'm not sure for the prototype scope though.

clang/lib/Parse/ParseExprCXX.cpp

1434

I'm not really familiar with clang (I usually work with other parts of LLVM), but at least in the current implementation (before this patch) the prototype scope englobes the parsing of lambda-specifiers, so I found it logical to keep it the same way.

[aaron.ballman]

I think this seems reasonable, but one question I have is: do we want to accept lambdas without parens in older C++ modes as an extension (with suitable compatibility warnings)?

[curdeius]

That's my question as well to be honest. I don't know what's the policy on that.
Anyway, it will simplify the code a bit I think.

[curdeius]

I've checked and GCC accepts lambdas without parens (but with specifiers) in all standard modes, giving a warning pre-C++2b.
I guess it's reasonable to align the behaviour.
Cf. https://github.com/gcc-mirror/gcc/commit/0f161cc8494cf7283a16fa9ebbcf8fd121bab68d#diff-e668c6c0533673af02f98ed35505230e0f6abdcc4f4814642ef619c93cadf794R11353-R11360, https://godbolt.org/z/5zK4M6.
I'll do it also then unless somebody opposes.

[aaron.ballman]

In D98433#2631037, @curdeius wrote:

I've checked and GCC accepts lambdas without parens (but with specifiers) in all standard modes, giving a warning pre-C++2b.
I guess it's reasonable to align the behaviour.
Cf. https://github.com/gcc-mirror/gcc/commit/0f161cc8494cf7283a16fa9ebbcf8fd121bab68d#diff-e668c6c0533673af02f98ed35505230e0f6abdcc4f4814642ef619c93cadf794R11353-R11360, https://godbolt.org/z/5zK4M6.
I'll do it also then unless somebody opposes.

I think that makes sense, thank you for looking into it!

[curdeius]

• Accept but warn in pre-C++2b mode when lambda is missing '()' and have lambda-specifiers.
• Fix tests.

[curdeius]

I'll fix the formatting with the next update.

clang/lib/Parse/ParseExprCXX.cpp

1444–1460

Is this really needed? May I simplify remove this switch and just have a generic warning message?

[aaron.ballman]

clang/lib/Parse/ParseExprCXX.cpp

1444–1460

I think a generic diagnostic would be reasonable. I think lambda without a parameter clause is a C++2b extension would be sufficiently clear.

[curdeius]

• Use a generic message.
• Fix formatting.

[curdeius]

• Format.

[aaron.ballman]

clang/lib/Parse/ParseExprCXX.cpp

1453

I believe you can remove this diagnostic from DiagnosticParseKinds.td now.

clang/test/Parser/cxx-concepts-requires-clause.cpp

161

Because you're touching the end of the file anyway, can you add the newline?

[curdeius]

• Address review comments (newline + remove diagnostic).

[aaron.ballman]

LGTM, thank you!

clang/include/clang/Basic/DiagnosticParseKinds.td

 def err_this_captured_by_reference : Error<
   "'this' cannot be captured by reference">;
 def err_expected_capture : Error<
   "expected variable name or 'this' in lambda capture list">;
 def err_expected_lambda_body : Error<"expected body of lambda expression">;
 def warn_cxx98_compat_lambda : Warning<
   "lambda expressions are incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
-def err_lambda_missing_parens : Error<
-  "lambda requires '()' before %select{'mutable'|return type|"
-  "attribute specifier|'constexpr'|'consteval'|'requires' clause}0">;
 def err_lambda_decl_specifier_repeated : Error<
   "%select{'mutable'|'constexpr'|'consteval'}0 cannot appear multiple times in a lambda declarator">;
 def err_lambda_capture_misplaced_ellipsis : Error<
   "ellipsis in pack %select{|init-}0capture must appear %select{after|before}0 "
   "the name of the capture">;
 def err_lambda_capture_multiple_ellipses : Error<
   "multiple ellipses in pack capture">;
 def err_capture_default_first : Error<
   "capture default must be first">;
 def ext_decl_attrs_on_lambda : ExtWarn<
   "an attribute specifier sequence in this position is a C++2b extension">,
   InGroup<CXX2b>;
+def ext_lambda_missing_parens : ExtWarn<
+  "lambda without a parameter clause is a C++2b extension">,
+  InGroup<CXX2b>;
 def warn_cxx20_compat_decl_attrs_on_lambda : Warning<
   "an attribute specifier sequence in this position is incompatible with C++ "
   "standards before C++2b">, InGroup<CXXPre2bCompat>, DefaultIgnore;
 
 // C++17 lambda expressions
 def err_expected_star_this_capture : Error<
   "expected 'this' following '*' in lambda capture list">;
 

clang/lib/Parse/ParseExprCXX.cpp

ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
   assert(!Result.isUnset() && "Typo correction suggested a keyword replacement "
                               "for a previous keyword suggestion");
   return Result;
 }
 
 /// ParseLambdaExpression - Parse a C++11 lambda expression.
 ///
 ///       lambda-expression:
-///         lambda-introducer lambda-declarator[opt] compound-statement
+///         lambda-introducer lambda-declarator compound-statement
 ///         lambda-introducer '<' template-parameter-list '>'
-///             lambda-declarator[opt] compound-statement
+///             lambda-declarator compound-statement
 ///
 ///       lambda-introducer:
 ///         '[' lambda-capture[opt] ']'
 ///
 ///       lambda-capture:
 ///         capture-default
 ///         capture-list
 ///         capture-default ',' capture-list

 ///         '&' identifier
 ///         'this'
 ///
 ///       init-capture:      [C++1y]
 ///         identifier initializer
 ///         '&' identifier initializer
 ///
 ///       lambda-declarator:
-///         '(' parameter-declaration-clause ')' attribute-specifier[opt]
-///           'mutable'[opt] exception-specification[opt]
-///           trailing-return-type[opt]
+///         lambda-specifiers     [C++2b]
+///         '(' parameter-declaration-clause ')' lambda-specifiers
+///             requires-clause[opt]
+///
+///       lambda-specifiers:
+///         decl-specifier-seq[opt] noexcept-specifier[opt]
+///             attribute-specifier-seq[opt] trailing-return-type[opt]
 ///
 ExprResult Parser::ParseLambdaExpression() {
   // Parse lambda-introducer.
   LambdaIntroducer Intro;
   if (ParseLambdaIntroducer(Intro)) {
     SkipUntil(tok::r_square, StopAtSemi);
     SkipUntil(tok::l_brace, StopAtSemi);
     SkipUntil(tok::r_brace, StopAtSemi);
ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
 
   // Parse lambda-declarator[opt].
   DeclSpec DS(AttrFactory);
   Declarator D(DS, DeclaratorContext::LambdaExpr);
   TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
   Actions.PushLambdaScope();
 
   ParsedAttributes Attr(AttrFactory);
-  SourceLocation DeclLoc = Tok.getLocation();
   if (getLangOpts().CUDA) {
     // In CUDA code, GNU attributes are allowed to appear immediately after the
     // "[...]", even if there is no "(...)" before the lambda body.
     MaybeParseGNUAttributes(D);
   }
 
   // Helper to emit a warning if we see a CUDA host/device/global attribute
   // after '(...)'. nvcc doesn't accept this.
if (isCXX11AttributeSpecifier()) {
     Diag(Tok, getLangOpts().CPlusPlus2b
                   ? diag::warn_cxx20_compat_decl_attrs_on_lambda
                   : diag::ext_decl_attrs_on_lambda);
     MaybeParseCXX11Attributes(D);
   }
 
   TypeResult TrailingReturnType;
   SourceLocation TrailingReturnTypeLoc;
-  if (Tok.is(tok::l_paren)) {
-    ParseScope PrototypeScope(this,
-                              Scope::FunctionPrototypeScope |
-                              Scope::FunctionDeclarationScope |
-                              Scope::DeclScope);
-
-    BalancedDelimiterTracker T(*this, tok::l_paren);
-    T.consumeOpen();
-    SourceLocation LParenLoc = T.getOpenLocation();
-
-    // Parse parameter-declaration-clause.
-    SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
-    SourceLocation EllipsisLoc;
-
-    if (Tok.isNot(tok::r_paren)) {
-      Actions.RecordParsingTemplateParameterDepth(
-          CurTemplateDepthTracker.getOriginalDepth());
-
-      ParseParameterDeclarationClause(D.getContext(), Attr, ParamInfo,
-                                      EllipsisLoc);
-      // For a generic lambda, each 'auto' within the parameter declaration
-      // clause creates a template type parameter, so increment the depth.
-      // If we've parsed any explicit template parameters, then the depth will
-      // 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();
-    SourceLocation RParenLoc = T.getCloseLocation();
+  auto ParseLambdaSpecifiers =
+      [&](SourceLocation LParenLoc, SourceLocation RParenLoc,
+          MutableArrayRef<DeclaratorChunk::ParamInfo> ParamInfo,
+          SourceLocation EllipsisLoc) {
         SourceLocation DeclEndLoc = RParenLoc;
 
-    // GNU-style attributes must be parsed before the mutable specifier to be
-    // compatible with GCC. MSVC-style attributes must be parsed before the
-    // mutable specifier to be compatible with MSVC.
+        // GNU-style attributes must be parsed before the mutable specifier to
+        // be compatible with GCC. MSVC-style attributes must be parsed before
+        // the mutable specifier to be compatible with MSVC.
         MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attr);
 
-    // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update the
-    // DeclEndLoc.
+        // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update
+        // the DeclEndLoc.
         SourceLocation MutableLoc;
         SourceLocation ConstexprLoc;
         SourceLocation ConstevalLoc;
         tryConsumeLambdaSpecifierToken(*this, MutableLoc, ConstexprLoc,
                                        ConstevalLoc, DeclEndLoc);
 
         addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
         addConstevalToLambdaDeclSpecifier(*this, ConstevalLoc, DS);
         // Parse exception-specification[opt].
         ExceptionSpecificationType ESpecType = EST_None;
         SourceRange ESpecRange;
         SmallVector<ParsedType, 2> DynamicExceptions;
         SmallVector<SourceRange, 2> DynamicExceptionRanges;
         ExprResult NoexceptExpr;
         CachedTokens *ExceptionSpecTokens;
-    ESpecType = tryParseExceptionSpecification(/*Delayed=*/false,
-                                               ESpecRange,
-                                               DynamicExceptions,
-                                               DynamicExceptionRanges,
-                                               NoexceptExpr,
-                                               ExceptionSpecTokens);
+        ESpecType = tryParseExceptionSpecification(
+            /*Delayed=*/false, ESpecRange, DynamicExceptions,
+            DynamicExceptionRanges, NoexceptExpr, ExceptionSpecTokens);
 
         if (ESpecType != EST_None)
           DeclEndLoc = ESpecRange.getEnd();
 
         // Parse attribute-specifier[opt].
         MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
 
         // Parse OpenCL addr space attribute.
         if (Tok.isOneOf(tok::kw___private, tok::kw___global, tok::kw___local,
                         tok::kw___constant, tok::kw___generic)) {
           ParseOpenCLQualifiers(DS.getAttributes());
           ConsumeToken();
         }
 
         SourceLocation FunLocalRangeEnd = DeclEndLoc;
 
         // Parse trailing-return-type[opt].
         if (Tok.is(tok::arrow)) {
           FunLocalRangeEnd = Tok.getLocation();
           SourceRange Range;
-      TrailingReturnType =
-          ParseTrailingReturnType(Range, /*MayBeFollowedByDirectInit*/ false);
+          TrailingReturnType = ParseTrailingReturnType(
+              Range, /*MayBeFollowedByDirectInit*/ false);
           TrailingReturnTypeLoc = Range.getBegin();
           if (Range.getEnd().isValid())
             DeclEndLoc = Range.getEnd();
         }
 
         SourceLocation NoLoc;
-    D.AddTypeInfo(DeclaratorChunk::getFunction(
-                      /*HasProto=*/true,
-                      /*IsAmbiguous=*/false, LParenLoc, ParamInfo.data(),
-                      ParamInfo.size(), EllipsisLoc, RParenLoc,
-                      /*RefQualifierIsLvalueRef=*/true,
-                      /*RefQualifierLoc=*/NoLoc, MutableLoc, ESpecType,
-                      ESpecRange, DynamicExceptions.data(),
-                      DynamicExceptionRanges.data(), DynamicExceptions.size(),
-                      NoexceptExpr.isUsable() ? NoexceptExpr.get() : nullptr,
-                      /*ExceptionSpecTokens*/ nullptr,
-                      /*DeclsInPrototype=*/None, LParenLoc, FunLocalRangeEnd, D,
-                      TrailingReturnType, TrailingReturnTypeLoc, &DS),
-                  std::move(Attr), DeclEndLoc);
+        D.AddTypeInfo(
+            DeclaratorChunk::getFunction(
+                /*RefQualifierLoc=*/NoLoc, MutableLoc, ESpecType, ESpecRange,
+                DynamicExceptions.data(), DynamicExceptionRanges.data(),
+                DynamicExceptions.size(),
 
         // Parse requires-clause[opt].
         if (Tok.is(tok::kw_requires))
           ParseTrailingRequiresClause(D);
 
-    PrototypeScope.Exit();
-
         WarnIfHasCUDATargetAttr();
-  } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
-                         tok::kw_constexpr, tok::kw_consteval,
-                         tok::kw___private, tok::kw___global, tok::kw___local,
-                         tok::kw___constant, tok::kw___generic,
-                         tok::kw_requires) ||
-             (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
-    // It's common to forget that one needs '()' before 'mutable', an attribute
-    // specifier, the result type, or the requires clause. Deal with this.
-    unsigned TokKind = 0;
-    switch (Tok.getKind()) {
-    case tok::kw_mutable: TokKind = 0; break;
-    case tok::arrow: TokKind = 1; break;
-    case tok::kw___attribute:
-    case tok::kw___private:
-    case tok::kw___global:
-    case tok::kw___local:
-    case tok::kw___constant:
-    case tok::kw___generic:
-    case tok::l_square: TokKind = 2; break;
-    case tok::kw_constexpr: TokKind = 3; break;
-    case tok::kw_consteval: TokKind = 4; break;
-    case tok::kw_requires: TokKind = 5; break;
-    default: llvm_unreachable("Unknown token kind");
-    }
+      };
 
-    Diag(Tok, diag::err_lambda_missing_parens)
-      << TokKind
-      << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
-    SourceLocation DeclEndLoc = DeclLoc;
+  if (Tok.is(tok::l_paren)) {
+    ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope |
+                                        Scope::FunctionDeclarationScope |
+                                        Scope::DeclScope);
 
-    // GNU-style attributes must be parsed before the mutable specifier to be
-    // compatible with GCC.
-    MaybeParseGNUAttributes(Attr, &DeclEndLoc);
+    BalancedDelimiterTracker T(*this, tok::l_paren);
+    T.consumeOpen();
+    SourceLocation LParenLoc = T.getOpenLocation();
 
-    // Parse 'mutable', if it's there.
-    SourceLocation MutableLoc;
-    if (Tok.is(tok::kw_mutable)) {
-      MutableLoc = ConsumeToken();
-      DeclEndLoc = MutableLoc;
-    }
+    // Parse parameter-declaration-clause.
+    SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
+    SourceLocation EllipsisLoc;
 
-    // Parse attribute-specifier[opt].
-    MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
+    if (Tok.isNot(tok::r_paren)) {
+      Actions.RecordParsingTemplateParameterDepth(
+          CurTemplateDepthTracker.getOriginalDepth());
 
-    // Parse the return type, if there is one.
-    if (Tok.is(tok::arrow)) {
-      SourceRange Range;
-      TrailingReturnType =
-          ParseTrailingReturnType(Range, /*MayBeFollowedByDirectInit*/ false);
-      if (Range.getEnd().isValid())
-        DeclEndLoc = Range.getEnd();
+      ParseParameterDeclarationClause(D.getContext(), Attr, ParamInfo,
+                                      EllipsisLoc);
+      // For a generic lambda, each 'auto' within the parameter declaration
+      // clause creates a template type parameter, so increment the depth.
+      // If we've parsed any explicit template parameters, then the depth will
+      // have already been incremented. So we make sure that at most a single
+      // depth level is added.
+      if (Actions.getCurGenericLambda())
+        CurTemplateDepthTracker.setAddedDepth(1);
     }
 
-    SourceLocation NoLoc;
-    D.AddTypeInfo(DeclaratorChunk::getFunction(
-                      /*HasProto=*/true,
-                      /*IsAmbiguous=*/false,
-                      /*LParenLoc=*/NoLoc,
-                      /*Params=*/nullptr,
-                      /*NumParams=*/0,
-                      /*EllipsisLoc=*/NoLoc,
-                      /*RParenLoc=*/NoLoc,
-                      /*RefQualifierIsLvalueRef=*/true,
-                      /*RefQualifierLoc=*/NoLoc, MutableLoc, EST_None,
-                      /*ESpecRange=*/SourceRange(),
-                      /*Exceptions=*/nullptr,
-                      /*ExceptionRanges=*/nullptr,
-                      /*NumExceptions=*/0,
-                      /*NoexceptExpr=*/nullptr,
-                      /*ExceptionSpecTokens=*/nullptr,
-                      /*DeclsInPrototype=*/None, DeclLoc, DeclEndLoc, D,
-                      TrailingReturnType),
-                  std::move(Attr), DeclEndLoc);
+    T.consumeClose();
 
-    // Parse the requires-clause, if present.
-    if (Tok.is(tok::kw_requires))
-      ParseTrailingRequiresClause(D);
+    // Parse lambda-specifiers.
+    ParseLambdaSpecifiers(LParenLoc, /*DeclEndLoc=*/T.getCloseLocation(),
+                          ParamInfo, EllipsisLoc);
+  } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
+                         tok::kw_constexpr, tok::kw_consteval,
+                         tok::kw___private, tok::kw___global, tok::kw___local,
+                         tok::kw___constant, tok::kw___generic,
+                         tok::kw_requires, tok::kw_noexcept) ||
+             (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
+    if (!getLangOpts().CPlusPlus2b)
+      // It's common to forget that one needs '()' before 'mutable', an
+      // attribute specifier, the result type, or the requires clause. Deal with
+      // this.
+      Diag(Tok, diag::ext_lambda_missing_parens)
+          << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
 
-    WarnIfHasCUDATargetAttr();
+    SourceLocation NoLoc;
+    // Parse lambda-specifiers.
+    std::vector<DeclaratorChunk::ParamInfo> EmptyParamInfo;
+    ParseLambdaSpecifiers(/*LParenLoc=*/NoLoc, /*RParenLoc=*/NoLoc,
+                          EmptyParamInfo, /*EllipsisLoc=*/NoLoc);
   }
 
   // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
   // it.
   unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope |
                         Scope::CompoundStmtScope;
   ParseScope BodyScope(this, ScopeFlags);
 
   Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
 
   // Parse compound-statement.
   if (!Tok.is(tok::l_brace)) {
     Diag(Tok, diag::err_expected_lambda_body);
     Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
     return ExprError();

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4-1y.cpp

int test_multiple_returns()  {
     M(3); // OK
     M('a'); //expected-note{{in instantiation of}}
   return 0;
 }
 int test_no_parameter_list()
 {
   static int si = 0;
     auto M = [] { return 5; }; // OK
-    auto M2 = [] -> auto&& { return si; }; // expected-error{{lambda requires '()'}}
+    auto M2 = [] -> auto && { return si; };
+#if __cplusplus <= 202002L
+      // expected-warning@-2{{is a C++2b extension}}
+#endif
     M();
 }
 
 int test_conditional_in_return() {
   auto Fac = [](auto f, auto n) { 
     return n <= 0 ? n : f(f, n - 1) * n;
   };
   // FIXME: this test causes a recursive limit - need to error more gracefully.
   //Fac(Fac, 3);
 
 }
 No newline at end of file

clang/test/FixIt/fixit-c++11.cpp

struct S2 {
   void f(int i); 
   void g(int i);
 };
 
 void S2::f(int i) {
   (void)[&, &i, &i]{}; // expected-error 2{{'&' cannot precede a capture when the capture default is '&'}}
   (void)[i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
   (void)[&, i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
-  (void)[] mutable { }; // expected-error{{lambda requires '()' before 'mutable'}}
-  (void)[] -> int { }; // expected-error{{lambda requires '()' before return type}}
+  (void)[] mutable {};
+  (void)[]->int{};
+#if __cplusplus <= 202002L
+  // expected-warning@-3{{is a C++2b extension}}
+  // expected-warning@-3{{is a C++2b extension}}
+#endif
 
   delete []() { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}}
   delete [] { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}}
 }
 
 #define bar "bar"
 const char *p = "foo"bar; // expected-error {{requires a space between}}
 #define ord - '0'

clang/test/Parser/cxx-concepts-requires-clause.cpp

 // RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2b -x c++ %s -verify
 
 // Test parsing of the optional requires-clause in a template-declaration.
 
 template <typename T> requires true
 void foo() { }
 
 template <typename T> requires (!0)
 struct A {
struct B {
   // expected-error@-1{{'this' cannot be used in a static member function declaration}}
 };
 
 auto lambda1 = [] (auto x) requires (sizeof(decltype(x)) == 1) { };
 
 auto lambda2 = [] (auto x) constexpr -> int requires (sizeof(decltype(x)) == 1) { return 0; };
 
 auto lambda3 = [] requires (sizeof(char) == 1) { };
-// expected-error@-1{{lambda requires '()' before 'requires' clause}}
+#if __cplusplus <= 202002L
+// expected-warning@-2{{is a C++2b extension}}
+#endif

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

 // RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++11 -Wno-c99-designator %s
 // RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++2a -Wno-c99-designator %s
+// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++2b -Wno-c99-designator %s
 
 enum E { e };
 
 constexpr int id(int n) { return n; }
 
 class C {
 
   int f() {
     int foo, bar;
 
     []; // expected-error {{expected body of lambda expression}}
     [+] {}; // expected-error {{expected variable name or 'this' in lambda capture list}}
     [foo+] {}; // expected-error {{expected ',' or ']' in lambda capture list}}
     [foo,&this] {}; // expected-error {{'this' cannot be captured by reference}}
     [&this] {}; // expected-error {{'this' cannot be captured by reference}}
     [&,] {}; // expected-error {{expected variable name or 'this' in lambda capture list}}
     [=,] {}; // expected-error {{expected variable name or 'this' in lambda capture list}}
-    [] {}; 
+    [] {};
     [=] (int i) {}; 
     [&] (int) mutable -> void {}; 
     [foo,bar] () { return 3; }; 
     [=,&foo] () {}; 
     [&,foo] () {}; 
     [this] () {}; 
     [] () -> class C { return C(); };
     [] () -> enum E { return e; };
 
-    [] -> int { return 0; }; // expected-error{{lambda requires '()' before return type}}
-    [] mutable -> int { return 0; }; // expected-error{{lambda requires '()' before 'mutable'}}
+    [] -> int { return 0; };
+    [] mutable -> int { return 0; };
+#if __cplusplus <= 202002L
+    // expected-warning@-3 {{lambda without a parameter clause is a C++2b extension}}
+    // expected-warning@-3 {{is a C++2b extension}}
+#endif
     [](int) -> {}; // PR13652 expected-error {{expected a type}}
     return 1;
   }
 
   void designator_or_lambda() {
     typedef int T; 
     const int b = 0; 
     const int c = 1;
#if __cplusplus <= 201103L
       // expected-warning@-3{{extension}}
 #endif
       r += 2;
       return x + 2;
     } ();
   }
 
   void attributes() {
-    [] __attribute__((noreturn)) {}; // expected-error {{lambda requires '()' before attribute specifier}}
+    [] __attribute__((noreturn)){};
+#if __cplusplus <= 202002L
+    // expected-warning@-2 {{is a C++2b extension}}
+#endif
     []() [[]]
       mutable {}; // expected-error {{expected body of lambda expression}}
 
     []() [[]] {};
     []() [[]] -> void {};
     []() mutable [[]] -> void {};
     []() mutable noexcept [[]] -> void {};
 
     // Testing GNU-style attributes on lambdas -- the attribute is specified
     // before the mutable specifier instead of after (unlike C++11).
     []() __attribute__((noreturn)) mutable { while(1); };
     []() mutable
       __attribute__((noreturn)) { while(1); }; // expected-error {{expected body of lambda expression}}
 
     // Testing support for P2173 on adding attributes to the declaration
     // rather than the type.
-    [] [[]] () {}; // expected-warning {{an attribute specifier sequence in this position is a C++2b extension}}
+    [][[]](){};
+#if __cplusplus <= 202002L
+    // expected-warning@-2 {{an attribute specifier sequence in this position is a C++2b extension}}
+#endif
 #if __cplusplus > 201703L
-    [] <typename> [[]] () {};  // expected-warning {{an attribute specifier sequence in this position is a C++2b extension}}
+    []<typename>[[]](){};
+#if __cplusplus <= 202002L
+    // expected-warning@-2 {{an attribute specifier sequence in this position is a C++2b extension}}
+#endif
+#endif
+    [][[]]{};
+#if __cplusplus <= 202002L
+    // expected-warning@-2 {{an attribute specifier sequence in this position is a C++2b extension}}
+#endif
+  }
+
+  void missing_parens() {
+    [] mutable {};
+    [] noexcept {};
+#if __cplusplus <= 202002L
+    // expected-warning@-3 {{is a C++2b extension}}
+    // expected-warning@-3 {{is a C++2b extension}}
 #endif
-    [] [[]] {}; // expected-warning {{an attribute specifier sequence in this position is a C++2b extension}}
   }
 };
 
 template <typename>
 void PR22122() {
   [](int) -> {}; // expected-error {{expected a type}}
 }
 

clang/test/Parser/cxx1z-constexpr-lambdas.cpp

-// RUN: %clang_cc1 -std=c++17 %s -verify 
-// RUN: %clang_cc1 -std=c++14 %s -verify 
-// RUN: %clang_cc1 -std=c++11 %s -verify 
+// RUN: %clang_cc1 -std=c++2b %s -verify
+// RUN: %clang_cc1 -std=c++20 %s -verify
+// RUN: %clang_cc1 -std=c++17 %s -verify
+// RUN: %clang_cc1 -std=c++14 %s -verify
+// RUN: %clang_cc1 -std=c++11 %s -verify
 
-
-auto XL0 = [] constexpr { }; //expected-error{{requires '()'}} expected-error{{expected body}}
-auto XL1 = [] () mutable 
-                 mutable     //expected-error{{cannot appear multiple times}}
-                 mutable { }; //expected-error{{cannot appear multiple times}}
+auto XL0 = [] constexpr { return true; };
+#if __cplusplus <= 201402L
+// expected-warning@-2 {{is a C++17 extension}}
+#endif
+#if __cplusplus <= 202002L
+// expected-warning@-5 {{lambda without a parameter clause is a C++2b extension}}
+#endif
+auto XL1 = []() mutable //
+    mutable             // expected-error{{cannot appear multiple times}}
+    mutable {};         // expected-error{{cannot appear multiple times}}
 
 #if __cplusplus > 201402L
 auto XL2 = [] () constexpr mutable constexpr { }; //expected-error{{cannot appear multiple times}}
 auto L = []() mutable constexpr { };
 auto L2 = []() constexpr { };
 auto L4 = []() constexpr mutable { }; 
 auto XL16 = [] () constexpr
                   mutable

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

+// RUN: %clang_cc1 -std=c++2b %s -verify
 // RUN: %clang_cc1 -std=c++2a %s -verify
 
 auto L0 = []<> { }; //expected-error {{cannot be empty}}
 
 auto L1 = []<typename T1, typename T2> { };
 auto L2 = []<typename T1, typename T2>(T1 arg1, T2 arg2) -> T1 { };
 auto L3 = []<typename T>(auto arg) { T t; };
 auto L4 = []<int I>() { };

clang/test/Parser/cxx2b-lambdas.cpp

+// RUN: %clang_cc1 -std=c++2b %s -verify
+
+auto LL0 = [] {};
+auto LL1 = []() {};
+auto LL2 = []() mutable {};
+auto LL3 = []() constexpr {};
+
+auto L0 = [] constexpr {};
+auto L1 = [] mutable {};
+auto L2 = [] noexcept {};
+auto L3 = [] constexpr mutable {};
+auto L4 = [] mutable constexpr {};
+auto L5 = [] constexpr mutable noexcept {};
+auto L6 = [s = 1] mutable {};
+auto L7 = [s = 1] constexpr mutable noexcept {};
+auto L8 = [] -> bool { return true; };
+auto L9 = []<typename T> { return true; };
+auto L10 = []<typename T> noexcept { return true; };
+auto L11 = []<typename T> -> bool { return true; };
+auto L12 = [] consteval {};
+auto L13 = [] requires requires() { true; }
+{};
+auto L15 = [] [[maybe_unused]]{};
+
+auto XL0 = [] mutable constexpr mutable {};    // expected-error{{cannot appear multiple times}}
+auto XL1 = [] constexpr mutable constexpr {};  // expected-error{{cannot appear multiple times}}
+auto XL2 = []) constexpr mutable constexpr {}; // expected-error{{expected body}}
+auto XL3 = []( constexpr mutable constexpr {}; // expected-error{{invalid storage class specifier}} \
+                                               // expected-error{{function parameter cannot be constexpr}} \
+                                               // expected-error{{C++ requires}} \
+                                               // expected-error{{expected ')'}} \
+                                               // expected-note{{to match this '('}} \
+                                               // expected-error{{expected body}} \
+                                               // expected-warning{{duplicate 'constexpr'}}

clang/test/SemaOpenCLCXX/address-space-lambda.clcpp

#endif
   const2(); //expected-error{{no matching function for call to object of type '__constant (lambda at}}
 //CHECK: |-CXXMethodDecl {{.*}} constexpr operator() 'void () {{.*}}const __constant'
   __constant auto const3 = []() __constant{};
   const3();
 
   [&] () __global {} (); //expected-error{{no matching function for call to object of type '(lambda at}} expected-note{{candidate function not viable: 'this' object is in default address space, but method expects object in address space '__global'}}
   [&] () __private {} (); //expected-error{{no matching function for call to object of type '(lambda at}} expected-note{{candidate function not viable: 'this' object is in default address space, but method expects object in address space '__private'}}
 
-  [&] __private {} (); //expected-error{{lambda requires '()' before attribute specifier}} expected-error{{expected body of lambda expression}}
+  [&] __private {} (); // expected-error{{no matching function for call to object of type '(lambda at}} expected-note{{candidate function not viable: 'this' object is in default address space, but method expects object in address space '__private'}}
+#if __cplusplus <= 202002L
+// expected-warning@-2{{lambda without a parameter clause is a C++2b extension}}
+#endif
 
   [&] () mutable __private {} ();
   [&] () __private mutable {} (); //expected-error{{expected body of lambda expression}}
 }
 

clang/www/cxx_status.html

 <tr>
  <td><a href="#cxx20">C++20</a></td>
  <td><tt>-std=c++20</tt></td>
  <td class="partial" align="center">Partial</td>
 </tr>
 <tr>
  <td><a href="#cxx23">C++2b (tentatively C++23)</a></td>
  <td><tt>-std=c++2b</tt></td>
- <td class="none" align="center">No</td>
+ <td class="partial" align="center">Partial</td>
 </tr>
 </table>
 
 <p>The Clang community is continually striving to improve C++ standards
 compliance between releases by submitting and tracking <a
 href="cxx_dr_status.html">C++ Defect Reports</a> and implementing resolutions
 as they become available.</p>
 
<tr>
       <td>Literal suffix <tt>uz</tt>, <tt>z</tt> for <tt>size_t</tt>, <tt>ssize_t</tt></td>
       <td><a href="https://wg21.link/p0330r8">P0330R8</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <!-- Spring 2021 papers -->
     <tr>
       <td>Make <tt>()</tt> in lambdas optional in all cases</td>
       <td><a href="https://wg21.link/p1102r2">P1102R2</a></td>
-      <td class="none" align="center">No</td>
+      <td class="full" align="center">Clang 13</td>
     </tr>
 </table>
 </details>
 
 <h2 id="dr">Defect reports</h2>
 
 <p>Clang generally aims to implement resolutions to Defect Reports (bug fixes
 against prior standards) retroactively, in all prior standard versions where