Add an ASTMatcher for ignoring ExprWithCleanups.

[timshen]

Summary

This is part of the fix of clang-tidy patterns to adapt to newly added ExprWithCleanups node.

[klimek]

Please add a test.

[aaron.ballman]

Also, please add documentation to the matcher definition and regenerate the documentation.

[timshen]

Done.

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

629

This documentation is used to generate the public docs, so it should include examples with matchers (of what does and does not match). It's especially important because this AST matcher may not be obvious to everyone as to why you'd use it or what it applies to.

633

Should be auto * (possibly const-qualified if you can get away with it).

[etienneb]

I was wondering why we didn't created that Matcher: IgnoreImplicit

I believe it's more commonly used than 'ignoringExprWithCleanups'.

It can be implemented by calling 'Stmt.IgnoreImplicit'.

/// Skip past any implicit AST nodes which might surround this
/// statement, such as ExprWithCleanups or ImplicitCastExpr nodes.
Stmt *IgnoreImplicit();

unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

2018

nit: you can lift that expression to a local variable:

varDecl(hasInitializer(ignoringExprWithCleanups(

ignoringParenImpCasts(integerLiteral()))))))

It's used 3 times.

[timshen]

I was wondering why we didn't created that Matcher: IgnoreImplicit

Actually you are right. There already exists a IgnoreImplict in clang-tidy and I just switched to that.

Abandoning this patch.

Thanks!

docs/LibASTMatchersReference.html

 
 Given
   class C {
   public:    int a;
   protected: int b;
   private:   int c;
   };
 fieldDecl(isPrivate())
-  matches 'int c;' 
+  matches 'int c;'
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isProtected0')"><a name="isProtected0Anchor">isProtected</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="isProtected0"><pre>Matches protected C++ declarations.
 
 Given
   class C {
   public:    int a;
   protected: int b;
   private:   int c;
   };
 fieldDecl(isProtected())
-  matches 'int b;' 
+  matches 'int b;'
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isPublic0')"><a name="isPublic0Anchor">isPublic</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="isPublic0"><pre>Matches public C++ declarations.
 
 Given
   class C {
   public:    int a;
   protected: int b;
   private:   int c;
   };
 fieldDecl(isPublic())
-  matches 'int a;' 
+  matches 'int a;'
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1DesignatedInitExpr.html">DesignatedInitExpr</a>&gt;</td><td class="name" onclick="toggle('designatorCountIs0')"><a name="designatorCountIs0Anchor">designatorCountIs</a></td><td>unsigned N</td></tr>
 <tr><td colspan="4" class="doc" id="designatorCountIs0"><pre>Matches designated initializer expressions that contain
 a specific number of designators.
 
 Example: Given
Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
             and U (matcher = typedefDecl(hasType(asString("int")))
  class X {};
  void y(X &amp;x) { x; X z; }
  typedef int U;
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringExprWithCleanups0')"><a name="ignoringExprWithCleanups0Anchor">ignoringExprWithCleanups</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
+<tr><td colspan="4" class="doc" id="ignoringExprWithCleanups0"><pre>Matches expressions that match InnerMatcher after ExprWithCleanups
+are stripped off.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringImpCasts0')"><a name="ignoringImpCasts0Anchor">ignoringImpCasts</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="ignoringImpCasts0"><pre>Matches expressions that match InnerMatcher after any implicit casts
 are stripped off.
 
 Parentheses and explicit casts are not discarded.
 Given
   int arr[5];
   int a = 0;

include/clang/ASTMatchers/ASTMatchers.h

 ///    varDecl(hasInitializer(integerLiteral()))
 ///    varDecl(hasInitializer(declRefExpr()))
 /// would only match the declaration for a.
 AST_MATCHER_P(Expr, ignoringParenImpCasts,
               internal::Matcher<Expr>, InnerMatcher) {
   return InnerMatcher.matches(*Node.IgnoreParenImpCasts(), Finder, Builder);
 }
 
+/// \brief Matches expressions that match InnerMatcher after ExprWithCleanups
+/// are stripped off.
+AST_MATCHER_P(Expr, ignoringExprWithCleanups, internal::Matcher<Expr>,
+              InnerMatcher) {
+  auto E = &Node;
+  if (auto Cleanups = dyn_cast<ExprWithCleanups>(E))
+    E = Cleanups->getSubExpr();
+  return InnerMatcher.matches(*E, Finder, Builder);
+}
+
 /// \brief Matches types that match InnerMatcher after any parens are stripped.
 ///
 /// Given
 /// \code
 ///   void (*fp)(void);
 /// \endcode
 /// The matcher
 /// \code

lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(hasThen);
   REGISTER_MATCHER(hasThreadStorageDuration);
   REGISTER_MATCHER(hasTrueExpression);
   REGISTER_MATCHER(hasTypeLoc);
   REGISTER_MATCHER(hasUnaryOperand);
   REGISTER_MATCHER(hasUnarySelector);
   REGISTER_MATCHER(hasValueType);
   REGISTER_MATCHER(ifStmt);
+  REGISTER_MATCHER(ignoringExprWithCleanups);
   REGISTER_MATCHER(ignoringImpCasts);
   REGISTER_MATCHER(ignoringParenCasts);
   REGISTER_MATCHER(ignoringParenImpCasts);
   REGISTER_MATCHER(ignoringParens);
   REGISTER_MATCHER(implicitCastExpr);
   REGISTER_MATCHER(implicitValueInitExpr);
   REGISTER_MATCHER(incompleteArrayType);
   REGISTER_MATCHER(initListExpr);

unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

EXPECT_TRUE(
     matches(
       CppString1,
       returnStmt(forFunction(hasName("operator()")),
                  has(integerLiteral()))));
   EXPECT_TRUE(matches(CppString2, returnStmt(forFunction(hasName("F2")))));
   EXPECT_TRUE(notMatches(CppString2, returnStmt(forFunction(hasName("F")))));
 }
 
+TEST(IgnoringExprWithCleanups, MatchesExprWithCleanups) {
+  EXPECT_TRUE(
+      matches("struct A { ~A(); }; A Foo(); A x = Foo();",
+              varDecl(hasInitializer(ignoringExprWithCleanups(
+                  cxxConstructExpr(has(materializeTemporaryExpr())))))));
+}
+
+TEST(IgnoringExprWithCleanups, MatchesWithoutExprWithCleanups) {
+  EXPECT_TRUE(matches(
+      "int x = 0; const int y = x;",
+      varDecl(hasInitializer(ignoringExprWithCleanups(
+          ignoringParenImpCasts(declRefExpr(to(varDecl(hasName("x"))))))))));
+}
+
+TEST(IgnoringExprWithCleanups, DoesNotMatchIncorrectly) {
+  EXPECT_TRUE(notMatches("char c = ((3));",
+                         varDecl(hasInitializer(ignoringExprWithCleanups(
+                             ignoringParenImpCasts(unless(anything())))))));
+  EXPECT_TRUE(notMatches("float y = (float(0));",
+                         varDecl(hasInitializer(ignoringExprWithCleanups(
+                             ignoringParenImpCasts(integerLiteral()))))));
+  EXPECT_TRUE(notMatches("float y = (float)0;",
+                         varDecl(hasInitializer(ignoringExprWithCleanups(
+                             ignoringParenImpCasts(integerLiteral()))))));
+  EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
+                         varDecl(hasInitializer(ignoringExprWithCleanups(
+                             ignoringParenImpCasts(integerLiteral()))))));
+}
+
 } // namespace ast_matchers
 } // namespace clang