Add new AST matcher `hasAnyCapture`

[rhiro]

Summary

Implement new AST matcher hasAnyCapture to match on LambdaExpr captures.

Accepts child matchers cxxThisExpr to match on capture of this and also on varDecl. This is achieved by using the overload macros.

[aaron.ballman]

Thank you for this patch! You should also register the matcher(s) in Registry.cpp so that they'll work from clang-query. Also, you need to regenerate the documentation by running clang\docs\tools\dump_ast_matchers.py

clang/include/clang/ASTMatchers/ASTMatchers.h

4056

I'm a bit less certain about the utility of this matcher. I would have assumed you could do hasAnyCapture(cxxThisExpr()) to get the same behavior, but I am guessing that won't work -- though you may be able to add an overload to hasAnyCapture() to make that work. I think that might be a better approach, if it works.

[rhiro]

• Change the hasCaptureThis functionality to be an override of hasAnyCapture with cxxThisExpr argument. Also generate the documentation and update tests.

[rhiro]

Thanks for the review! I regenerated the docs and switched the this capture case to be an override of hasAnyCapture.

clang/include/clang/ASTMatchers/ASTMatchers.h

4056

Thanks for that idea, it does seem a bit cleaner.

It would be nice if we could write a Matcher<LambdaCapture>, so that the macro composition could be more generically nested. e.g. hasAnyCapture that just loops over the LambdaCaptures and passes them to the child matcher. However, when I tried this, it became apparent that it is not a Node type that can be matched on, and would require nontrivial changes.

[aaron.ballman]

clang/include/clang/ASTMatchers/ASTMatchers.h

4032–4034

I would prefer to see this written as: if (Capture.capturesVariable()) { ... } so it's a bit more resilient to other non-var captures like VLA captures.

4056

Yeah, I think this would require some work within the guts of the AST matchers and I'm not certain it would be worth the effort yet.

4058–4063

return llvm::any_of(Node.captures(), [](const LambdaCapture &LC) { return LC.capturesThis(); });

[rhiro]

Fixed the condition for the varDecl case and made the cxxThisExpr more concise.

• Condition on capturesVariable instead of capturesThis and switch the loop in the cxxThisExpr overload to use llvm::any_of instead of an explicit loop.

[rhiro]

I addressed the inline comments.

[aaron.ballman]

LGTM! Do you need someone to commit on your behalf?

[rhiro]

In D72414#1814831, @aaron.ballman wrote:

LGTM! Do you need someone to commit on your behalf?

Yes, please.

[aaron.ballman]

Thank you! I have commit on your behalf in 4ffcec40acebae7161ac7426edc68290bbaca2b8

clang/include/clang/ASTMatchers/ASTMatchers.h

 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
+#include "clang/AST/LambdaCapture.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/StmtOpenMP.h"
 #include "clang/AST/TemplateBase.h"
for (const Expr *Arg : Node.arguments()) {
     if (InnerMatcher.matches(*Arg, Finder, &Result)) {
       *Builder = std::move(Result);
       return true;
     }
   }
   return false;
 }
 
+/// Matches any capture of a lambda expression.
+///
+/// Given
+/// \code
+///   void foo() {
+///     int x;
+///     auto f = [x](){};
+///   }
+/// \endcode
+/// lambdaExpr(hasAnyCapture(anything()))
+///   matches [x](){};
+AST_MATCHER_P(LambdaExpr, hasAnyCapture, internal::Matcher<VarDecl>,
+              InnerMatcher) {
+  for (const LambdaCapture &Capture : Node.captures()) {
+    if (Capture.capturesThis()) {
+      continue;
+    }
+    BoundNodesTreeBuilder Result(*Builder);
+    if (InnerMatcher.matches(*Capture.getCapturedVar(), Finder, &Result)) {
+      *Builder = std::move(Result);
+      return true;
+    }
+  }
+  return false;
+}
+
+/// Matches any capture of 'this' in a lambda expression.
+///
+/// Given
+/// \code
+///   struct foo {
+///     void bar() {
+///       auto f = [this](){};
+///     }
+///   }
+/// \endcode
+/// lambdaExpr(capturesThis())
+///   matches [this](){};
+AST_MATCHER(LambdaExpr, capturesThis) {
+  for (const LambdaCapture &Capture : Node.captures()) {
+    if (Capture.capturesThis()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 /// Matches a constructor call expression which uses list initialization.
 AST_MATCHER(CXXConstructExpr, isListInitialization) {
   return Node.isListInitialization();
 }
 
 /// Matches a constructor call expression which requires
 /// zero initialization.
 ///

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

EXPECT_TRUE(matchesObjC(
       objcMessageExpr(hasReceiver(declRefExpr(to(varDecl(hasName("x"))))))));
 
   EXPECT_FALSE(matchesObjC(
       "@interface NSString +(NSString *) stringWithFormat; @end "
       "void f() { [NSString stringWithFormat]; }",
       objcMessageExpr(hasReceiver(declRefExpr(to(varDecl(hasName("x"))))))));
 }
 
+TEST(Matcher, HasAnyCapture) {
+  auto HasCaptureX = lambdaExpr(hasAnyCapture(varDecl(hasName("x"))));
+  EXPECT_TRUE(matches("void f() { int x = 3; [x](){}; }", HasCaptureX));
+  EXPECT_TRUE(matches("void f() { int x = 3; [&x](){}; }", HasCaptureX));
+  EXPECT_TRUE(notMatches("void f() { [](){}; }", HasCaptureX));
+  EXPECT_TRUE(notMatches("void f() { int z = 3; [&z](){}; }", HasCaptureX));
+  EXPECT_TRUE(
+      notMatches("struct a { void f() { [this](){}; }; };", HasCaptureX));
+}
+
+TEST(Matcher, CapturesThis) {
+  auto HasCaptureThis = lambdaExpr(capturesThis());
+  EXPECT_TRUE(
+      matches("struct a { void f() { [this](){}; }; };", HasCaptureThis));
+  EXPECT_TRUE(notMatches("void f() { [](){}; }", HasCaptureThis));
+  EXPECT_TRUE(notMatches("void f() { int x = 3; [x](){}; }", HasCaptureThis));
+  EXPECT_TRUE(notMatches("void f() { int x = 3; [&x](){}; }", HasCaptureThis));
+  EXPECT_TRUE(notMatches("void f() { int z = 3; [&z](){}; }", HasCaptureThis));
+}
+
 TEST(Matcher, isClassMessage) {
   EXPECT_TRUE(matchesObjC(
       "@interface NSString +(NSString *) stringWithFormat; @end "
       "void f() { [NSString stringWithFormat]; }",
       objcMessageExpr(isClassMessage())));
 
   EXPECT_FALSE(matchesObjC(
       "@interface NSString @end "