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

[cor3ntin]

Summary

Partially implement P0315R4.

This patch allow lambda in unevaluated context.
It does not implement temp.deduct/9.

This is a rewrite of https://reviews.llvm.org/D66481 that did
not see progress over the past 2 years.

[cor3ntin]

Code formatting

[cjdb]

Thanks for working on this, it'll be a huge win for testing in libc++, methinks!

Could we get a few more tests please? I'd like to know what happens when we put a lambda directly inside:

• a SFINAE expression
• a noexcept specifier
• a sizeof operator

Similarly for lambdas inside decltype for each of the above. It'd also be good to have lambdas that aren't called as well.

[cor3ntin]

Add more tests

[cjdb]

LGTM, but I'm neither a Clang nor core expert (and I'm not a maintainer), so please wait for others' approval.

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

9

Nit: please move this under line 3.

22

Nit: please move this under line 3.

[cor3ntin]

Cleanup tests

[aaron.ballman]

Thanks for working on this!

It does not implement temp.deduct/9.

Is there a reason why?

clang/lib/Sema/SemaConcept.cpp

44–48

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

2

This test doesn't really have anything to do with [expr.prim.lambda]p2 as it appears in C++20 and later, it's more testing the words that used to live in p2 in C++17 and earlier no longer apply.

I think the functionality in the test is good, but should either be moved to the correct file based on what property is being tested or should be moved out of the CXX directory and into SemaCXX (or a combination of both). I'd recommend going through the examples presented in the wording of https://wg21.link/p0315r4 and make a test for each.

5

I'd appreciate a test that shows you can also use a lambda that is not immediately invoked.

14

Can you add the newline to the end of the file?

21

I think it's important to have some tests that show two lambdas are never equivalent (http://eel.is/c++draft/temp.over.link#5.sentence-4). Given the intent specified in the standard, I think a super useful case would be:

template <typename Ty, typename Uy>
auto func() -> decltype(Ty{}.operator()(Uy{})) { return 1; }

int main() {
  auto lambda = [](auto i){ return i; };
  func<decltype(lambda), int>();
}

I *think* that will cause the lambda to be mangled as part of the trailing return type.

Other tests would be typical type equivalence tests (like using std::is_same).

[cor3ntin]

Typos, add more tests

[cor3ntin]

Move tests to SemaCXX

[cjdb]

When should we expect this to land?

[cor3ntin]

In D103380#2823746, @cjdb wrote:

When should we expect this to land?

Thanks for the nudge, Chris!
Please let me know if I can help move this forward :)

[aaron.ballman]

I think this is incremental progress that LGTM, but let's wait a few days in case @rsmith has concerns before landing.

[aaron.ballman]

Thank you for the patch! I've committed in 22aa3680eaccb9b77ca224711c4da3a354aa2d45.

clang/lib/Sema/SemaConcept.cpp

 
 public:
   LogicalBinOp(const Expr *E) {
     if (auto *BO = dyn_cast<BinaryOperator>(E)) {
       Op = BinaryOperator::getOverloadedOperator(BO->getOpcode());
       LHS = BO->getLHS();
       RHS = BO->getRHS();
     } else if (auto *OO = dyn_cast<CXXOperatorCallExpr>(E)) {
+        if(OO->getNumArgs() == 2) {
           Op = OO->getOperator();
           LHS = OO->getArg(0);
           RHS = OO->getArg(1);
       }
     }
+  }
 
   bool isAnd() const { return Op == OO_AmpAmp; }
   bool isOr() const { return Op == OO_PipePipe; }
   explicit operator bool() const { return isAnd() || isOr(); }
 
   const Expr *getLHS() const { return LHS; }
   const Expr *getRHS() const { return RHS; }
 };

clang/lib/Sema/SemaExpr.cpp

 }
 
 void Sema::PopExpressionEvaluationContext() {
   ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back();
   unsigned NumTypos = Rec.NumTypos;
 
   if (!Rec.Lambdas.empty()) {
     using ExpressionKind = ExpressionEvaluationContextRecord::ExpressionKind;
-    if (Rec.ExprContext == ExpressionKind::EK_TemplateArgument || Rec.isUnevaluated() ||
-        (Rec.isConstantEvaluated() && !getLangOpts().CPlusPlus17)) {
+    if (!getLangOpts().CPlusPlus20 && (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:

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

+// RUN: %clang_cc1 -std=c++20 %s -verify
+// expected-no-diagnostics
+
+template<auto> struct Nothing {};
+
+template<typename T>
+concept True = [] { return true; }();
+
+static_assert(True<int>);
+
+using x = decltype([] { return 0;}());
+
+Nothing<[]() { return 0; }()> nothing;

clang/test/SemaCXX/anonymous-struct.cpp

 typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
   int x = 0; // expected-note {{type is not C-compatible due to this default member initializer}} expected-warning 0-1{{extension}}
 } B; // expected-note {{type is given name 'B' for linkage purposes by this typedef declaration}}
 
 typedef struct // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
 : B { // expected-note {{type is not C-compatible due to this base class}}
 } C; // expected-note {{type is given name 'C' for linkage purposes by this typedef declaration}}
 
-#if __cplusplus > 201703L
+#if __cplusplus > 201703L && __cplusplus < 202002L
 typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
   static_assert([]{ return true; }()); // expected-note {{type is not C-compatible due to this lambda expression}}
 } Lambda1; // expected-note {{type is given name 'Lambda1' for linkage purposes by this typedef declaration}}
 
 template<int> struct X {};
 typedef struct { // expected-warning {{anonymous non-C-compatible type given name for linkage purposes by typedef declaration; add a tag name here}}
   X<[]{ return 0; }()> x; // expected-note {{type is not C-compatible due to this lambda expression}}
   // FIXME: expected-error@-1 {{lambda expression cannot appear}}

clang/www/cxx_status.html

</tr>
     <tr>
       <td>Default constructible and assignable stateless lambdas</td>
       <td><a href="https://wg21.link/p0624r2">P0624R2</a></td>
       <td class="full" align="center">Clang 8</td>
     </tr>
     <tr>
       <td>Lambdas in unevaluated contexts</td>
       <td><a href="https://wg21.link/p0315r4">P0315R4</a></td>
-      <td class="none" align="center">No</td>
+      <td class="partial" align="center">Clang 13</td>
     </tr>
     <!-- Jacksonville papers -->
     <tr>
       <td><tt>[[no_unique_address]]</tt> attribute</td>
       <td><a href="https://wg21.link/p0840r2">P0840R2</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <tr>