[ASTMatchers] overload ignoringParens for Expr

[JonasToth]

Summary

This patch allows fixing PR39583.

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

814–815

Can you do this via AST_POLYMORPHIC_MATCHER_P instead, given that the implementation is the same?

[aaron.ballman]

Also: the patch is missing unit tests.

[JonasToth]

include/clang/ASTMatchers/ASTMatchers.h

814–815

Do you want me to add more types? e.g. TypeLoc has IgnoreParens(), too.

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

814–815

I'd not be opposed, given that we already expose the typeLoc() matcher. I'll leave that to your discretion.

[JonasToth]

• add unit test

include/clang/ASTMatchers/ASTMatchers.h

814–815

as discussed on IRC making it an AST_POLYMORPHIC_MATCHER_P does not seem to work, as the polymorphism is only in the return type. We do need the Node itself to be polymorphic (same type as returntype). The only working version I got was using the overloads.

[aaron.ballman]

Adding a few other reviewers in case they have ideas on how to use the polymorphic matcher rather than the overload. If they don't have a better idea, then I think the overload approach is fine.

[sbenza]

include/clang/ASTMatchers/ASTMatchers.h

814–815

You can't use AST_POLYMORPHIC_MATCHER_P to overload on input types.
You could try using templates, but that will make registering the matcher harder.
Another one that does input+output polymorphism, id, is simply not supported dynamically.

[aaron.ballman]

LGTM!

include/clang/ASTMatchers/ASTMatchers.h

814–815

Good to know, thank you!

[JonasToth]

include/clang/ASTMatchers/ASTMatchers.h

814–815

thanks for clarifying.

[JonasToth]

• add unit test

docs/LibASTMatchersReference.html

 would match the declarations for a, b, c, and d, but not e.
 while
    varDecl(hasInitializer(integerLiteral()))
    varDecl(hasInitializer(declRefExpr()))
 would only match the declaration for a.
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('ignoringParens1')"><a name="ignoringParens1Anchor">ignoringParens</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
+<tr><td colspan="4" class="doc" id="ignoringParens1"><pre>Overload ignoringParens for Expr.
+
+Given
+  const char* str = ("my-string");
+The matcher
+  implicitCastExpr(hasSourceExpression(ignoringParens(stringLiteral())))
+would match the implicit cast resulting from the assignment.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;</td><td class="name" onclick="toggle('hasInClassInitializer0')"><a name="hasInClassInitializer0Anchor">hasInClassInitializer</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="hasInClassInitializer0"><pre>Matches non-static data members that have an in-class initializer.
 
 Given
   class C {
     int a = 2;
     int b = 3;
     int c;

include/clang/ASTMatchers/ASTMatchers.h

 /// \code
 ///   void (*fp)(void);
 /// \endcode
 /// The matcher
 /// \code
 ///   varDecl(hasType(pointerType(pointee(ignoringParens(functionType())))))
 /// \endcode
 /// would match the declaration for fp.
-AST_MATCHER_P(QualType, ignoringParens,
-              internal::Matcher<QualType>, InnerMatcher) {
+AST_MATCHER_P_OVERLOAD(QualType, ignoringParens, internal::Matcher<QualType>,
+                       InnerMatcher, 0) {
   return InnerMatcher.matches(Node.IgnoreParens(), Finder, Builder);
 }
 
+/// Overload \c ignoringParens for \c Expr.
+///
+/// Given
+/// \code
+///   const char* str = ("my-string");
+/// \endcode
+/// The matcher
+/// \code
+///   implicitCastExpr(hasSourceExpression(ignoringParens(stringLiteral())))
+/// \endcode
+/// would match the implicit cast resulting from the assignment.
+AST_MATCHER_P_OVERLOAD(Expr, ignoringParens, internal::Matcher<Expr>,
+                       InnerMatcher, 1) {
+  const Expr *E = Node.IgnoreParens();
+  return InnerMatcher.matches(*E, Finder, Builder);
+}
+
 /// Matches expressions that are instantiation-dependent even if it is
 /// neither type- nor value-dependent.
 ///
 /// In the following example, the expression sizeof(sizeof(T() + T()))
 /// is instantiation-dependent (since it involves a template parameter T),
 /// but is neither type- nor value-dependent, since the type of the inner
 /// sizeof is known (std::size_t) and therefore the size of the outer
 /// sizeof is known.

lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   // findAll
   //
   // Other:
   // equalsNode
 
   REGISTER_OVERLOADED_2(callee);
   REGISTER_OVERLOADED_2(hasPrefix);
   REGISTER_OVERLOADED_2(hasType);
+  REGISTER_OVERLOADED_2(ignoringParens);
   REGISTER_OVERLOADED_2(isDerivedFrom);
   REGISTER_OVERLOADED_2(isSameOrDerivedFrom);
   REGISTER_OVERLOADED_2(loc);
   REGISTER_OVERLOADED_2(pointsTo);
   REGISTER_OVERLOADED_2(references);
   REGISTER_OVERLOADED_2(thisPointerType);
 
   std::unique_ptr<MatcherDescriptor> equalsCallbacks[] = {
RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(hasUnderlyingType);
   REGISTER_MATCHER(hasUnqualifiedDesugaredType);
   REGISTER_MATCHER(hasValueType);
   REGISTER_MATCHER(ifStmt);
   REGISTER_MATCHER(ignoringImpCasts);
   REGISTER_MATCHER(ignoringImplicit);
   REGISTER_MATCHER(ignoringParenCasts);
   REGISTER_MATCHER(ignoringParenImpCasts);
-  REGISTER_MATCHER(ignoringParens);
   REGISTER_MATCHER(imaginaryLiteral);
   REGISTER_MATCHER(implicitCastExpr);
   REGISTER_MATCHER(implicitValueInitExpr);
   REGISTER_MATCHER(incompleteArrayType);
   REGISTER_MATCHER(initListExpr);
   REGISTER_MATCHER(injectedClassNameType);
   REGISTER_MATCHER(innerType);
   REGISTER_MATCHER(integerLiteral);

unittests/ASTMatchers/ASTMatchersNodeTest.cpp

 TEST(ParenExpression, SimpleCases) {
   EXPECT_TRUE(matches("int i = (3);", parenExpr()));
   EXPECT_TRUE(matches("int i = (3 + 7);", parenExpr()));
   EXPECT_TRUE(notMatches("int i = 3;", parenExpr()));
   EXPECT_TRUE(notMatches("int foo() { return 1; }; int a = foo();",
                          parenExpr()));
 }
 
+TEST(ParenExpression, IgnoringParens) {
+  EXPECT_FALSE(matches("const char* str = (\"my-string\");",
+                       implicitCastExpr(hasSourceExpression(stringLiteral()))));
+  EXPECT_TRUE(matches(
+      "const char* str = (\"my-string\");",
+      implicitCastExpr(hasSourceExpression(ignoringParens(stringLiteral())))));
+}
+
 TEST(TypeMatching, MatchesTypes) {
   EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
 }
 
 TEST(TypeMatching, MatchesConstantArrayTypes) {
   EXPECT_TRUE(matches("int a[2];", constantArrayType()));
   EXPECT_TRUE(notMatches(
     "void f() { int a[] = { 2, 3 }; int b[a[0]]; }",