[C++20] Support for lambdas in unevaluated context

[• krzysztof-jusiak]

Summary

Problem:

• Lambdas in unevaluated context aren't supported in the newest clang yet but are required for our usage of jit.

Solution:

• Add support for lambdas in unevaluated context.

[riccibruno]

Can you submit the patch with the full context (ie: git diff -U9999999) ?

[lebedev.ri]

Doesn't this inadvertently allow them in every standard? That seems wrong.

[• krzysztof-jusiak]

In D66481#1637525, @riccibruno wrote:

Can you submit the patch with the full context (ie: git diff -U9999999) ?

Sure, will do it

[• krzysztof-jusiak]

In D66481#1637530, @lebedev.ri wrote:

Doesn't this inadvertently allow them in every standard? That seems wrong.

Good point, you are right, will fix it and resubmit 👍

[sjanel]

Hello,

Any news on this? GCC and MSVC support them since a while now.

Thanks a lot in advance !

Stephane

[cor3ntin]

Given the lack of activity, I made another PR for the same feature https://reviews.llvm.org/D103380

clang/lib/Sema/SemaExpr.cpp

     if (Rec.ExprContext == ExpressionKind::EK_TemplateArgument || Rec.isUnevaluated() ||
         (Rec.isConstantEvaluated() && !getLangOpts().CPlusPlus17)) {
       unsigned D;
-      if (Rec.isUnevaluated()) {
-        // C++11 [expr.prim.lambda]p2:
-        //   A lambda-expression shall not appear in an unevaluated operand
-        //   (Clause 5).
-        D = diag::err_lambda_unevaluated_operand;
-      } else if (Rec.isConstantEvaluated() && !getLangOpts().CPlusPlus17) {
-        // C++1y [expr.const]p2:
-        //   A conditional-expression e is a core constant expression unless the
-        //   evaluation of e, following the rules of the abstract machine, would
-        //   evaluate [...] a lambda-expression.
-        D = diag::err_lambda_in_constant_expression;
-      } else if (Rec.ExprContext == ExpressionKind::EK_TemplateArgument) {
+        if (Rec.ExprContext == ExpressionKind::EK_TemplateArgument) {
         // C++17 [expr.prim.lamda]p2:
         // A lambda-expression shall not appear [...] in a template-argument.
         D = diag::err_lambda_in_invalid_context;

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p2.cpp

 };
 
 void unevaluated_operand(P &p, int i) {
-  int i2 = sizeof([] ()->int { return 0; }()); // expected-error{{lambda expression in an unevaluated operand}}
+  int i2 = sizeof([] ()->int { return 0; }());
   const std::type_info &ti1 = typeid([&]() -> P& { return p; }());
-  const std::type_info &ti2 = typeid([&]() -> int { return i; }());  // expected-error{{lambda expression in an unevaluated operand}}
+  const std::type_info &ti2 = typeid([&]() -> int { return i; }());
 }
 
 template<typename T>

   // because the copy-initialization of the capture of boom_float occurs in an
   // unevaluated operand.
   const std::type_info &ti2
-    = typeid([=]() -> int { boom_float.tickle(); return 0; }()); // expected-error{{lambda expression in an unevaluated operand}}
+    = typeid([=]() -> int { boom_float.tickle(); return 0; }());
 
   auto foo = [=]() -> int { boom_double.tickle(); return 0; }; // expected-note{{in instantiation of member function 'Boom<double>::Boom' requested here}}
 }