[clang] Fix printing of lambdas with capture expressions

[kadircet]

clang/lib/AST/StmtPrinter.cpp

2011

what about having a Pre and Post print blocks, set to "(" and ")" or " = and ""` respectively?

that way we could get rid of the second if block below.

also i don't follow why blacklisting for parenlistexpr is needed here (i can see that it will end up printing double parens, but so is ParenExprs, and I think both of them shouldn't be showing up as initializer exprs of captured variables), could you elaborate with a comment and a test case?

[walrus]

clang/lib/AST/StmtPrinter.cpp

2011

I think you're right that skipping ParenListExpr is wrong here. I took this part of code from DeclPrinter. The ParenListExprs are skipped when printing variable declarations, but I think it is not applicable when printing lambda expression captures.

Honestly, I didn't get about Pre and Post blocks. I know it is supported when printing types, but I could not find how to do this for expressions.

[kadircet]

clang/lib/AST/StmtPrinter.cpp

2011

i meant something like below, (modulo naming):

llvm::StringRef Pre;
llvm::StringRef Post;
if(Style == CallInit) {
  Pre = "(";
  Post = ")";
}
else if (Style == CInit)
  Pre = " = ";

OS << Pre;
PrintExpr(Init):
OS << Post;

[walrus]

Simplify code according to suggestions in code review

[walrus]

Remove unused struct definition

[walrus]

clang/lib/AST/StmtPrinter.cpp

2011

Thank you for your suggestion - this makes code more clear. Regarding ParenListExpr exception - I investigated this case and found that this is necessary to prevent double braces when capturing variables of dependent unresolved types, e.g.:

template <typename T>
void foo(T var) {

  auto lambda = [m(var)] {};
}

Here expression m(var) resolves in ParenListExpr which will print braces on its own.

I added a couple of test cases to validate this behavior.

[kadircet]

thanks, lgtm!

clang/lib/AST/StmtPrinter.cpp

2014

ah, now i see the use for it, thanks for the testcase !

could you please and with the previous condition rather than extra nesting.

2018

nit: braces

[walrus]

Simplify if..else statement, add braces

[kadircet]

do you have commit access? if not I am happy to land this for you.

After having some commits done on your behalf, you can apply for commit access as described in https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

[walrus]

In D83855#2155303, @kadircet wrote:

thanks, lgtm!

Thank you much for the review!

I do not have commit access. Could you please commit the changes on my behalf?
Ilya Golovenko <[e-mail]>

clang/lib/AST/StmtPrinter.cpp

for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(),
 
     case LCK_VLAType:
       llvm_unreachable("VLA type in explicit captures.");
     }
 
     if (C->isPackExpansion())
       OS << "...";
 
-    if (Node->isInitCapture(C))
-      PrintExpr(C->getCapturedVar()->getInit());
+    if (Node->isInitCapture(C)) {
+      VarDecl *D = C->getCapturedVar();
+
+      llvm::StringRef Pre;
+      llvm::StringRef Post;
+      if (D->getInitStyle() == VarDecl::CallInit &&
+          !isa<ParenListExpr>(D->getInit())) {
+        Pre = "(";
+        Post = ")";
+      } else if (D->getInitStyle() == VarDecl::CInit) {
+        Pre = " = ";
+      }
+
+      OS << Pre;
+      PrintExpr(D->getInit());
+      OS << Post;
+    }
   }
   OS << ']';
 
   if (!Node->getExplicitTemplateParameters().empty()) {
     Node->getTemplateParameterList()->print(
         OS, Node->getLambdaClass()->getASTContext(),
         /*OmitTemplateKW*/true);
   }

clang/test/AST/ast-printer-lambda.cpp

void test1(int i, T... t) {
   auto lambda = [=]{};
   //CHECK: [=] {
 }
 {
   auto lambda = [&]{};
   //CHECK: [&] {
 }
 {
+  auto lambda = [k{i}] {};
+  //CHECK: [k{i}] {
+}
+{
+  auto lambda = [k(i)] {};
+  //CHECK: [k(i)] {
+}
+{
+  auto lambda = [k = i] {};
+  //CHECK: [k = i] {
+}
+{
   auto lambda = [t..., i]{};
   //CHECK: [t..., i] {
 }
 {
   auto lambda = [&t...]{};
   //CHECK: [&t...] {
 }
 {
   auto lambda = [this, &t...]{};
   //CHECK: [this, &t...] {
 }
 {
   auto lambda = [t..., this]{};
   //CHECK: [t..., this] {
 }
+{
+  auto lambda = [k(t...)] {};
+  //CHECK: [k(t...)] {
+}
+{
+  auto lambda = [k{t...}] {};
+  //CHECK: [k{t...}] {
+}
 }
 
 };
 No newline at end of file