Customize simplified dumping and matching of LambdaExpr

[steveire]

Update

[steveire]

Update

[aaron.ballman]

LGTM aside from some nits.

clang/include/clang/AST/ASTNodeTraverser.h

134

This seems like it may be over the 80 col limit?

661

const CXXMethodDecl *, or just sink it into the range-based for loop since we don't really need the local anyway.

662

const auto *

clang/lib/ASTMatchers/ASTMatchFinder.cpp

219

You can elide the braces, also you can remove the else after a return.

223–224

if (const TemplateParameterList *TPL = Node->getTemplateParameterList()) {
  ...
}

226

Elide braces

232

const CXXMethodDecl *

234

Elide braces

[thakis]

Looks like this might break tests: http://45.33.8.238/linux/6150/step_7.txt

clang/include/clang/AST/ASTNodeTraverser.h

getNodeDelegate().AddChild(Label, [=] {
 
       if (!S) {
         return;
       }
 
       ConstStmtVisitor<Derived>::Visit(S);
 
       // Some statements have custom mechanisms for dumping their children.
-      if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)) {
+      if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S) ||
+          isa<LambdaExpr>(S)) {
         return;
       }
 
       for (const Stmt *SubStmt : S->children())
         Visit(SubStmt);
     });
   }
 
   void Visit(QualType T) {
     SplitQualType SQT = T.split();
void VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
     Visit(E->getControllingExpr()->getType()); // FIXME: remove
 
     for (const auto Assoc : E->associations()) {
       Visit(Assoc);
     }
   }
 
   void VisitLambdaExpr(const LambdaExpr *Node) {
-    Visit(Node->getLambdaClass());
+    if (Traversal == ast_type_traits::TK_IgnoreUnlessSpelledInSource) {
+      for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) {
+        const auto *C = Node->capture_begin() + I;
+        if (!C->isExplicit())
+          continue;
+        if (Node->isInitCapture(C))
+          Visit(C->getCapturedVar());
+        else
+          Visit(Node->capture_init_begin()[I]);
+      }
+      dumpTemplateParameters(Node->getTemplateParameterList());
+      auto CallOp = Node->getCallOperator();
+      for (auto *P : CallOp->parameters())
+        Visit(P);
+      Visit(Node->getBody());
+    } else {
+      return Visit(Node->getLambdaClass());
+    }
   }
 
   void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
     if (Node->isPartiallySubstituted())
       for (const auto &A : Node->getPartialArguments())
         Visit(A);
   }
 

clang/lib/ASTMatchers/ASTMatchFinder.cpp

public:
   }
   bool TraverseStmt(Stmt *StmtNode, DataRecursionQueue *Queue = nullptr) {
     // If we need to keep track of the depth, we can't perform data recursion.
     if (CurrentDepth == 0 || (CurrentDepth <= MaxDepth && MaxDepth < INT_MAX))
       Queue = nullptr;
 
     ScopedIncrement ScopedDepth(&CurrentDepth);
     Stmt *StmtToTraverse = StmtNode;
-    if (auto *ExprNode = dyn_cast_or_null<Expr>(StmtNode))
+    if (auto *ExprNode = dyn_cast_or_null<LambdaExpr>(StmtNode))
+      StmtToTraverse = ExprNode;
+    else if (auto *ExprNode = dyn_cast_or_null<Expr>(StmtNode))
       StmtToTraverse = Finder->getASTContext().traverseIgnored(ExprNode);
     if (Traversal ==
         ast_type_traits::TraversalKind::TK_IgnoreImplicitCastsAndParentheses) {
       if (Expr *ExprNode = dyn_cast_or_null<Expr>(StmtNode))
         StmtToTraverse = ExprNode->IgnoreParenImpCasts();
     }
     if (!StmtToTraverse)
       return true;
bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
     return traverse(NNS);
   }
   bool TraverseConstructorInitializer(CXXCtorInitializer *CtorInit) {
     if (!CtorInit)
       return true;
     ScopedIncrement ScopedDepth(&CurrentDepth);
     return traverse(*CtorInit);
   }
+  bool TraverseLambdaExpr(LambdaExpr *Node) {
+    if (!Node)
+      return true;
+    ScopedIncrement ScopedDepth(&CurrentDepth);
+
+    for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) {
+      const auto *C = Node->capture_begin() + I;
+      if (!C->isExplicit())
+        continue;
+      if (Node->isInitCapture(C) && !match(*C->getCapturedVar())) {
+        return false;
+      } else if (!match(*Node->capture_init_begin()[I])) {
+        return false;
+      }
+    }
+    auto *TPL = Node->getTemplateParameterList();
+    if (TPL) {
+      for (const auto *TP : *TPL) {
+        if (!match(*TP)) {
+          return false;
+        }
+      }
+    }
+
+    auto CallOp = Node->getCallOperator();
+    for (auto *P : CallOp->parameters()) {
+      if (!match(*P)) {
+        return false;
+      }
+    }
+
+    if (!match(*Node->getBody()))
+      return false;
+
+    return false;
+  }
 
   bool shouldVisitTemplateInstantiations() const { return true; }
   bool shouldVisitImplicitCode() const { return true; }
 
 private:
   // Used for updating the depth during traversal.
   struct ScopedIncrement {
     explicit ScopedIncrement(int *Depth) : Depth(Depth) { ++(*Depth); }

clang/unittests/AST/ASTTraverserTest.cpp

 
 public:
   NodeTreePrinter(llvm::raw_ostream &OS)
       : TextTreeStructure(OS, /* showColors */ false), OS(OS) {}
 
   void Visit(const Decl *D) {
     OS << D->getDeclKindName() << "Decl";
     if (auto *ND = dyn_cast<NamedDecl>(D)) {
-      OS << " '" << ND->getDeclName() << "'";
+      OS << " '" << ND->getNameAsString() << "'";
     }
   }
 
   void Visit(const Stmt *S) {
     OS << S->getStmtClassName();
     if (auto *E = dyn_cast<DeclRefExpr>(S)) {
-      OS << " '" << E->getDecl()->getDeclName() << "'";
+      OS << " '" << E->getDecl()->getNameAsString() << "'";
     }
   }
 
   void Visit(QualType QT) {
     OS << "QualType " << QT.split().Quals.getAsString();
   }
 
   void Visit(const Type *T) { OS << T->getTypeClassName() << "Type"; }
`-CompoundStmt
   |-DeclStmt
   | `-VarDecl 'c'
   |   `-CXXConstructExpr
   `-ReturnStmt
     `-DeclRefExpr 'c'
 )cpp");
 }
 
+TEST(Traverse, LambdaUnlessSpelledInSource) {
+
+  auto AST =
+      buildASTFromCodeWithArgs(R"cpp(
+
+void captures() {
+  int a = 0;
+  int b = 0;
+  int d = 0;
+  int f = 0;
+
+  [a, &b, c = d, &e = f](int g, int h = 42) {};
+}
+
+void templated() {
+  int a = 0;
+  [a]<typename T>(T t) {};
+}
+
+struct SomeStruct {
+    int a = 0;
+    void capture_this() {
+        [this]() {};
+    }
+    void capture_this_copy() {
+        [self = *this]() {};
+    }
+};
+)cpp",
+                               {"-Wno-unused-value", "-Wno-c++2a-extensions"});
+
+  auto getLambdaNode = [&AST](const std::string &name) {
+    auto BN = ast_matchers::match(
+        lambdaExpr(hasAncestor(functionDecl(hasName(name)))).bind("lambda"),
+        AST->getASTContext());
+    EXPECT_EQ(BN.size(), 1u);
+    return BN[0].getNodeAs<LambdaExpr>("lambda");
+  };
+
+  {
+    auto L = getLambdaNode("captures");
+
+    EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L),
+              R"cpp(
+LambdaExpr
+|-DeclRefExpr 'a'
+|-DeclRefExpr 'b'
+|-VarDecl 'c'
+| `-DeclRefExpr 'd'
+|-VarDecl 'e'
+| `-DeclRefExpr 'f'
+|-ParmVarDecl 'g'
+|-ParmVarDecl 'h'
+| `-IntegerLiteral
+`-CompoundStmt
+)cpp");
+
+    EXPECT_EQ(dumpASTString(ast_type_traits::TK_AsIs, L),
+              R"cpp(
+LambdaExpr
+`-CXXRecordDecl ''
+  |-CXXMethodDecl 'operator()'
+  | |-ParmVarDecl 'g'
+  | |-ParmVarDecl 'h'
+  | | `-IntegerLiteral
+  | `-CompoundStmt
+  |-FieldDecl ''
+  |-FieldDecl ''
+  |-FieldDecl ''
+  |-FieldDecl ''
+  `-CXXDestructorDecl '~'
+)cpp");
+  }
+
+  {
+    auto L = getLambdaNode("templated");
+
+    EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L),
+              R"cpp(
+LambdaExpr
+|-DeclRefExpr 'a'
+|-TemplateTypeParmDecl 'T'
+|-ParmVarDecl 't'
+`-CompoundStmt
+)cpp");
+  }
+
+  {
+    auto L = getLambdaNode("capture_this");
+
+    EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L),
+              R"cpp(
+LambdaExpr
+|-CXXThisExpr
+`-CompoundStmt
+)cpp");
+  }
+
+  {
+    auto L = getLambdaNode("capture_this_copy");
+
+    EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L),
+              R"cpp(
+LambdaExpr
+|-VarDecl 'self'
+| `-UnaryOperator
+|   `-CXXThisExpr
+`-CompoundStmt
+)cpp");
+  }
+}
+
 } // namespace clang

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

B func11() {
   return b;
 }
 
 B func12() {
   C c;
   return c;
 }
 
+void func13() {
+  int a = 0;
+  int c = 0;
+
+  [a, b = c](int d) { int e = d; };
+}
+
+void func14() {
+  [] <typename TemplateType> (TemplateType t, TemplateType u) { int e = t + u; };
+}
+
 )cpp";
 
   EXPECT_TRUE(matches(
       Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func1"))),
                                 hasReturnValue(integerLiteral(equals(42)))))));
 
   EXPECT_TRUE(matches(
EXPECT_TRUE(matches(
                                 hasReturnValue(
                                     declRefExpr(to(varDecl(hasName("b")))))))));
 
   EXPECT_TRUE(matches(
       Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func12"))),
                                 hasReturnValue(
                                     declRefExpr(to(varDecl(hasName("c")))))))));
+
+  EXPECT_TRUE(matches(
+      Code,
+      traverse(
+          ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+          lambdaExpr(forFunction(functionDecl(hasName("func13"))),
+                     has(compoundStmt(hasDescendant(varDecl(hasName("e"))))),
+                     has(declRefExpr(to(varDecl(hasName("a"))))),
+                     has(varDecl(hasName("b"), hasInitializer(declRefExpr(to(
+                                                   varDecl(hasName("c"))))))),
+                     has(parmVarDecl(hasName("d")))))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     lambdaExpr(
+                         forFunction(functionDecl(hasName("func14"))),
+                         has(templateTypeParmDecl(hasName("TemplateType")))))));
 }
 
 TEST(IgnoringImpCasts, MatchesImpCasts) {
   // This test checks that ignoringImpCasts matches when implicit casts are
   // present and its inner matcher alone does not match.
   // Note that this test creates an implicit const cast.
   EXPECT_TRUE(matches("int x = 0; const int y = x;",
                       varDecl(hasInitializer(ignoringImpCasts(