[ASTMatchers] has matcher matching as is

[Prazek]

Summary

All tests passes. I used git-clang-format to format code, but I am not sure if it is totally legit right now (maybe running clang-format on whole file would change also above lines)

[klimek]

Thanks! Did you change all has() to has(ignoringParenImpCasts())? I wonder how many times we could remove the ignoringParenImpCasts without breaking any tests.

[Prazek]

Not all - in unit tests I added it only to places where it was required.
To clang-tidy checks I added it everywhere, where inner matcher was expr.

BTW I am not sure if there should be some assertion for ignoringParenImpCast, when inner matcher is stmt. Right now it compiles, but of course
has(stmt()) doesnt match the same things as has(ignoringParenImpCast(stmt())), and it kinda doesn't make sense so I guess it should fail with compiler error.

[klimek]

In D20801#444044, @Prazek wrote:

Not all - in unit tests I added it only to places where it was required.
To clang-tidy checks I added it everywhere, where inner matcher was expr.

BTW I am not sure if there should be some assertion for ignoringParenImpCast, when inner matcher is stmt. Right now it compiles, but of course
has(stmt()) doesnt match the same things as has(ignoringParenImpCast(stmt())), and it kinda doesn't make sense so I guess it should fail with compiler error.

Why doesn't it make sense?

[Prazek]

Not all - in unit tests I added it only to places where it was required.
To clang-tidy checks I added it everywhere, where inner matcher was expr.

BTW I am not sure if there should be some assertion for ignoringParenImpCast, when inner matcher is stmt. Right now it compiles, but of course
has(stmt()) doesnt match the same things as has(ignoringParenImpCast(stmt())), and it kinda doesn't make sense so I guess it should fail with compiler error.

In D20801#444049, @klimek wrote:

In D20801#444044, @Prazek wrote:

Not all - in unit tests I added it only to places where it was required.
To clang-tidy checks I added it everywhere, where inner matcher was expr.

BTW I am not sure if there should be some assertion for ignoringParenImpCast, when inner matcher is stmt. Right now it compiles, but of course
has(stmt()) doesnt match the same things as has(ignoringParenImpCast(stmt())), and it kinda doesn't make sense so I guess it should fail with compiler error.

Why doesn't it make sense?

Maybe I don't understand it correctly, but I see in the documentation that ignoringParenImpCasts takes Matcher<Expr> as InnerMatcher, so I don't know what it even accept Matcher<Stmt>

[klimek]

In D20801#444103, @Prazek wrote:

Not all - in unit tests I added it only to places where it was required.
To clang-tidy checks I added it everywhere, where inner matcher was expr.

BTW I am not sure if there should be some assertion for ignoringParenImpCast, when inner matcher is stmt. Right now it compiles, but of course
has(stmt()) doesnt match the same things as has(ignoringParenImpCast(stmt())), and it kinda doesn't make sense so I guess it should fail with compiler error.

In D20801#444049, @klimek wrote:

In D20801#444044, @Prazek wrote:

Not all - in unit tests I added it only to places where it was required.
To clang-tidy checks I added it everywhere, where inner matcher was expr.

BTW I am not sure if there should be some assertion for ignoringParenImpCast, when inner matcher is stmt. Right now it compiles, but of course
has(stmt()) doesnt match the same things as has(ignoringParenImpCast(stmt())), and it kinda doesn't make sense so I guess it should fail with compiler error.

Why doesn't it make sense?

Maybe I don't understand it correctly, but I see in the documentation that ignoringParenImpCasts takes Matcher<Expr> as InnerMatcher, so I don't know what it even accept Matcher<Stmt>

As Expr is a subclass of Stmt (yes, this is somewhat unexpected, and a long story), Matcher<Stmt> is a subclass of Matcher<Expr>; it is a reverse hierarchy.

[xazax.hun]

This should be mentioned in the release notes, since it is a breaking change, lot of out of tree checks might be broken due to this one. And also it might be worth to consider those checks that utilizing the has matcher and did not break after the change. Maybe we were just "lucky" (or more like unlucky).

[Prazek]

In D20801#444145, @xazax.hun wrote:

This should be mentioned in the release notes, since it is a breaking change, lot of out of tree checks might be broken due to this one. And also it might be worth to consider those checks that utilizing the has matcher and did not break after the change. Maybe we were just "lucky" (or more like unlucky).

That's why I have changed all ocurences of has matcher in clang-extra to has(ignoringParenImpCasts(. I will add note in release notes

[Prazek]

+ note in release notes

[klimek]

Gábor, you happy?

[xazax.hun]

In D20801#444369, @klimek wrote:

Gábor, you happy?

Sure, LGTM :)

[klimek]

LG, thanks!

[Prazek]

No problem, I like to make my job simpler :)

clang-tidy/cert/ThrownExceptionTypeCheck.cpp

 namespace tidy {
 namespace cert {
 
 void ThrownExceptionTypeCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(
-      cxxThrowExpr(
-          has(cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
+      cxxThrowExpr(has(ignoringParenImpCasts(
+          cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
                                isCopyConstructor(), unless(isNoThrow()))))
-          .bind("expr"))),
+              .bind("expr")))),
       this);
 }
 
 void ThrownExceptionTypeCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
   diag(E->getExprLoc(),
        "thrown exception type is not nothrow copy constructible");
 }
 
 } // namespace cert
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/BoolPointerImplicitConversionCheck.cpp

void BoolPointerImplicitConversionCheck::check(
   // Check that we don't dereference the variable anywhere within the if. This
   // avoids false positives for checks of the pointer for nullptr before it is
   // dereferenced. If there is a dereferencing operator on this variable don't
   // emit a diagnostic. Also ignore array subscripts.
   const Decl *D = Var->getDecl();
   auto DeclRef = ignoringParenImpCasts(declRefExpr(to(equalsNode(D))));
   if (!match(findAll(
                  unaryOperator(hasOperatorName("*"), hasUnaryOperand(DeclRef))),
-             *If, *Result.Context).empty() ||
+             *If, *Result.Context)
+           .empty() ||
       !match(findAll(arraySubscriptExpr(hasBase(DeclRef))), *If,
-             *Result.Context).empty() ||
+             *Result.Context)
+           .empty() ||
       // FIXME: We should still warn if the paremater is implicitly converted to
       // bool.
       !match(findAll(callExpr(hasAnyArgument(ignoringParenImpCasts(DeclRef)))),
              *If, *Result.Context)
            .empty() ||
-      !match(findAll(cxxDeleteExpr(has(expr(DeclRef)))), *If, *Result.Context)
+      !match(findAll(cxxDeleteExpr(has(ignoringParenImpCasts(expr(DeclRef))))),
+             *If, *Result.Context)
            .empty())
     return;
 
   diag(Var->getLocStart(), "dubious check of 'bool *' against 'nullptr', did "
                            "you mean to dereference it?")
       << FixItHint::CreateInsertion(Var->getLocStart(), "*");
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/DanglingHandleCheck.cpp

 
 void DanglingHandleCheck::registerMatchersForVariables(MatchFinder *Finder) {
   const auto ConvertedHandle = handleFromTemporaryValue(IsAHandle);
 
   // Find 'Handle foo(ReturnsAValue());'
   Finder->addMatcher(
       varDecl(hasType(cxxRecordDecl(IsAHandle)),
               hasInitializer(
-                  exprWithCleanups(has(ConvertedHandle)).bind("bad_stmt"))),
+                  exprWithCleanups(has(ignoringParenImpCasts(ConvertedHandle)))
+                      .bind("bad_stmt"))),
       this);
 
   // Find 'Handle foo = ReturnsAValue();'
   Finder->addMatcher(
-      varDecl(hasType(cxxRecordDecl(IsAHandle)), unless(parmVarDecl()),
-              hasInitializer(
-                  exprWithCleanups(has(handleFrom(IsAHandle, ConvertedHandle)))
+      varDecl(
+          hasType(cxxRecordDecl(IsAHandle)), unless(parmVarDecl()),
+          hasInitializer(exprWithCleanups(has(ignoringParenImpCasts(handleFrom(
+                                              IsAHandle, ConvertedHandle))))
                              .bind("bad_stmt"))),
       this);
   // Find 'foo = ReturnsAValue();  // foo is Handle'
   Finder->addMatcher(
       cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(IsAHandle))),
                           hasOverloadedOperatorName("="),
                           hasArgument(1, ConvertedHandle))
           .bind("bad_stmt"),
       this);
 
   // Container insertions that will dangle.
   Finder->addMatcher(makeContainerMatcher(IsAHandle).bind("bad_stmt"), this);
 }
 
 void DanglingHandleCheck::registerMatchersForReturn(MatchFinder *Finder) {
   // Return a local.
   Finder->addMatcher(
       returnStmt(
           // The AST contains two constructor calls:
           //   1. Value to Handle conversion.
           //   2. Handle copy construction.
           // We have to match both.
-          has(handleFrom(
+          has(ignoringParenImpCasts(handleFrom(
               IsAHandle,
               handleFrom(IsAHandle, declRefExpr(to(varDecl(
                                         // Is function scope ...
                                         hasAutomaticStorageDuration(),
                                         // ... and it is a local array or Value.
                                         anyOf(hasType(arrayType()),
                                               hasType(recordDecl(
-                                                  unless(IsAHandle)))))))))),
+                                                  unless(IsAHandle))))))))))),
           // Temporary fix for false positives inside lambdas.
           unless(hasAncestor(lambdaExpr())))
           .bind("bad_stmt"),
       this);
 
   // Return a temporary.
   Finder->addMatcher(
-      returnStmt(has(exprWithCleanups(has(handleFrom(
-                     IsAHandle, handleFromTemporaryValue(IsAHandle))))))
+      returnStmt(
+          has(ignoringParenImpCasts(exprWithCleanups(has(ignoringParenImpCasts(
+              handleFrom(IsAHandle, handleFromTemporaryValue(IsAHandle))))))))
           .bind("bad_stmt"),
       this);
 }
 
 void DanglingHandleCheck::registerMatchers(MatchFinder *Finder) {
   registerMatchersForVariables(Finder);
   registerMatchersForReturn(Finder);
 }

clang-tidy/misc/InaccurateEraseCheck.cpp

 
 void InaccurateEraseCheck::registerMatchers(MatchFinder *Finder) {
   // Only register the matchers for C++; the functionality currently does not
   // provide any benefit to other languages, despite being benign.
   if (!getLangOpts().CPlusPlus)
     return;
 
   const auto CheckForEndCall = hasArgument(
-      1, anyOf(cxxConstructExpr(
-                   has(cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end"))))
-                           .bind("InaccEndCall"))),
+      1, anyOf(cxxConstructExpr(has(ignoringParenImpCasts(
+                   cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end"))))
+                       .bind("InaccEndCall")))),
                anything()));
 
   Finder->addMatcher(
       cxxMemberCallExpr(
           on(hasType(namedDecl(matchesName("^::std::")))),
           callee(cxxMethodDecl(hasName("erase"))), argumentCountIs(1),
-          hasArgument(0, has(callExpr(callee(functionDecl(matchesName(
+          hasArgument(0, has(ignoringParenImpCasts(
+                             callExpr(callee(functionDecl(matchesName(
                                           "^::std::(remove(_if)?|unique)$"))),
                                       CheckForEndCall)
-                                 .bind("InaccAlgCall"))),
+                                 .bind("InaccAlgCall")))),
           unless(isInTemplateInstantiation()))
           .bind("InaccErase"),
       this);
 }
 
 void InaccurateEraseCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MemberCall =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("InaccErase");

clang-tidy/misc/IncorrectRoundings.cpp

void IncorrectRoundings::registerMatchers(MatchFinder *MatchFinder) {
   auto FloatHalf = floatLiteral(floatHalf());
 
   // Match a floating point expression.
   auto FloatType = expr(hasType(realFloatingPointType()));
 
   // Match a floating literal of 0.5 or a floating literal of 0.5 implicitly.
   // cast to floating type.
   auto FloatOrCastHalf =
-      anyOf(FloatHalf, implicitCastExpr(FloatType, has(FloatHalf)));
+      anyOf(FloatHalf,
+            implicitCastExpr(FloatType, has(ignoringParenImpCasts(FloatHalf))));
 
   // Match if either the LHS or RHS is a floating literal of 0.5 or a floating
   // literal of 0.5 and the other is of type double or vice versa.
   auto OneSideHalf = anyOf(allOf(hasLHS(FloatOrCastHalf), hasRHS(FloatType)),
                            allOf(hasRHS(FloatOrCastHalf), hasLHS(FloatType)));
 
   // Find expressions of cast to int of the sum of a floating point expression
   // and 0.5.

clang-tidy/misc/InefficientAlgorithmCheck.cpp

const auto ContainerMatcher = classTemplateSpecializationDecl(hasAnyName(
       "::std::set", "::std::map", "::std::multiset", "::std::multimap",
       "::std::unordered_set", "::std::unordered_map",
       "::std::unordered_multiset", "::std::unordered_multimap"));
 
   const auto Matcher =
       callExpr(
           callee(functionDecl(Algorithms)),
           hasArgument(
-              0, cxxConstructExpr(has(cxxMemberCallExpr(
+              0, cxxConstructExpr(has(ignoringParenImpCasts(cxxMemberCallExpr(
                      callee(cxxMethodDecl(hasName("begin"))),
                      on(declRefExpr(
                             hasDeclaration(decl().bind("IneffContObj")),
                             anyOf(hasType(ContainerMatcher.bind("IneffCont")),
                                   hasType(pointsTo(
                                       ContainerMatcher.bind("IneffContPtr")))))
-                            .bind("IneffContExpr")))))),
-          hasArgument(1, cxxConstructExpr(has(cxxMemberCallExpr(
-                             callee(cxxMethodDecl(hasName("end"))),
-                             on(declRefExpr(hasDeclaration(
-                                 equalsBoundNode("IneffContObj")))))))),
+                            .bind("IneffContExpr"))))))),
+          hasArgument(
+              1, cxxConstructExpr(has(ignoringParenImpCasts(cxxMemberCallExpr(
+                     on(declRefExpr(
+                         hasDeclaration(equalsBoundNode("IneffContObj"))))))))),
           hasArgument(2, expr().bind("AlgParam")),
           unless(isInTemplateInstantiation()))
           .bind("IneffAlg");
 
   Finder->addMatcher(Matcher, this);
 }
 
 void InefficientAlgorithmCheck::check(const MatchFinder::MatchResult &Result) {

clang-tidy/misc/MisplacedWideningCastCheck.cpp

void MisplacedWideningCastCheck::registerMatchers(MatchFinder *Finder) {
   const auto Calc =
       expr(anyOf(binaryOperator(
                      anyOf(hasOperatorName("+"), hasOperatorName("-"),
                            hasOperatorName("*"), hasOperatorName("<<"))),
                  unaryOperator(hasOperatorName("~"))),
            hasType(isInteger()))
           .bind("Calc");
 
-  const auto ExplicitCast =
-      explicitCastExpr(hasDestinationType(isInteger()), has(Calc));
+  const auto ExplicitCast = explicitCastExpr(hasDestinationType(isInteger()),
+                                             has(ignoringParenImpCasts(Calc)));
   const auto ImplicitCast =
-      implicitCastExpr(hasImplicitDestinationType(isInteger()), has(Calc));
+      implicitCastExpr(hasImplicitDestinationType(isInteger()),
+                       has(ignoringParenImpCasts(Calc)));
   const auto Cast = expr(anyOf(ExplicitCast, ImplicitCast)).bind("Cast");
 
   Finder->addMatcher(varDecl(hasInitializer(Cast)), this);
   Finder->addMatcher(returnStmt(hasReturnValue(Cast)), this);
   Finder->addMatcher(callExpr(hasAnyArgument(Cast)), this);
   Finder->addMatcher(binaryOperator(hasOperatorName("="), hasRHS(Cast)), this);
   Finder->addMatcher(
       binaryOperator(matchers::isComparisonOperator(),

clang-tidy/misc/SizeofContainerCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace misc {  
 
 void SizeofContainerCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       expr(unless(isInTemplateInstantiation()),
-           expr(sizeOfExpr(has(
+           expr(sizeOfExpr(has(ignoringParenImpCasts(
                     expr(hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
                         matchesName("^(::std::|::string)"),
                         unless(matchesName("^::std::(bitset|array)$")),
                         hasMethod(cxxMethodDecl(hasName("size"), isPublic(),
-                                                isConst()))))))))))
+                                                isConst())))))))))))
                .bind("sizeof"),
            // Ignore ARRAYSIZE(<array of containers>) pattern.
            unless(hasAncestor(binaryOperator(
                anyOf(hasOperatorName("/"), hasOperatorName("%")),
                hasLHS(ignoringParenCasts(sizeOfExpr(expr()))),
                hasRHS(ignoringParenCasts(equalsBoundNode("sizeof"))))))),
       this);
 }

clang-tidy/misc/SizeofExpressionCheck.cpp

 void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
   const auto IntegerExpr = ignoringParenImpCasts(integerLiteral());
   const auto ConstantExpr = expr(ignoringParenImpCasts(
       anyOf(integerLiteral(), unaryOperator(hasUnaryOperand(IntegerExpr)),
             binaryOperator(hasLHS(IntegerExpr), hasRHS(IntegerExpr)))));
   const auto SizeOfExpr =
       expr(anyOf(sizeOfExpr(has(type())), sizeOfExpr(has(expr()))));
   const auto SizeOfZero = expr(
-      sizeOfExpr(has(expr(ignoringParenImpCasts(integerLiteral(equals(0)))))));
+      sizeOfExpr(has(ignoringParenImpCasts(expr(integerLiteral(equals(0)))))));
 
   // Detect expression like: sizeof(ARRAYLEN);
   // Note: The expression 'sizeof(sizeof(0))' is a portable trick used to know
   //       the sizeof size_t.
   if (WarnOnSizeOfConstant) {
-    Finder->addMatcher(expr(sizeOfExpr(has(ConstantExpr)), unless(SizeOfZero))
-                           .bind("sizeof-constant"),
-                       this);
+    Finder->addMatcher(
+        expr(sizeOfExpr(has(ignoringParenImpCasts(ConstantExpr))),
+             unless(SizeOfZero))
   }
 
   // Detect expression like: sizeof(this);
   if (WarnOnSizeOfThis) {
     Finder->addMatcher(
-        expr(sizeOfExpr(has(expr(ignoringParenImpCasts(cxxThisExpr())))))
+        expr(sizeOfExpr(has(ignoringParenImpCasts(expr(cxxThisExpr())))))
             .bind("sizeof-this"),
         this);
   }
 
   // Detect sizeof(kPtr) where kPtr is 'const char* kPtr = "abc"';
   const auto CharPtrType = pointerType(pointee(isAnyCharacter()));
   const auto ConstStrLiteralDecl =
       varDecl(isDefinition(), hasType(qualType(hasCanonicalType(CharPtrType))),
               hasInitializer(ignoringParenImpCasts(stringLiteral())));
-  Finder->addMatcher(
-      expr(sizeOfExpr(has(expr(hasType(qualType(hasCanonicalType(CharPtrType))),
-                               ignoringParenImpCasts(declRefExpr(
-                                   hasDeclaration(ConstStrLiteralDecl)))))))
+  Finder->addMatcher(expr(sizeOfExpr(has(ignoringParenImpCasts(expr(
+                              hasType(qualType(hasCanonicalType(CharPtrType))),
+                                  hasDeclaration(ConstStrLiteralDecl))))))))
                          .bind("sizeof-charp"),
                      this);
 
   // Detect sizeof(ptr) where ptr points to an aggregate (i.e. sizeof(&S)).
   const auto ArrayExpr = expr(ignoringParenImpCasts(
       expr(hasType(qualType(hasCanonicalType(arrayType()))))));
   const auto ArrayCastExpr = expr(anyOf(
       unaryOperator(hasUnaryOperand(ArrayExpr), unless(hasOperatorName("*"))),
       binaryOperator(hasEitherOperand(ArrayExpr)),
       castExpr(hasSourceExpression(ArrayExpr))));
Finder->addMatcher(
                      hasEitherOperand(ignoringParenImpCasts(binaryOperator(
                          hasOperatorName("*"),
                          hasEitherOperand(ignoringParenImpCasts(SizeOfExpr))))))
           .bind("sizeof-multiply-sizeof"),
       this);
 
   // Detect strange double-sizeof expression like: sizeof(sizeof(...));
   // Note: The expression 'sizeof(sizeof(0))' is accepted.
-  Finder->addMatcher(expr(sizeOfExpr(has(expr(hasSizeOfDescendant(
-                              8, expr(SizeOfExpr, unless(SizeOfZero)))))))
-                         .bind("sizeof-sizeof-expr"),
-                     this);
+  Finder->addMatcher(
+      expr(sizeOfExpr(has(ignoringParenImpCasts(expr(
+               hasSizeOfDescendant(8, expr(SizeOfExpr, unless(SizeOfZero))))))))
 }
 
 void SizeofExpressionCheck::check(const MatchFinder::MatchResult &Result) {
   const ASTContext &Ctx = *Result.Context;
 
   if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-constant")) {
     diag(E->getLocStart(),
          "suspicious usage of 'sizeof(K)'; did you mean 'K'?");

clang-tidy/misc/StaticAssertCheck.cpp

StaticAssertCheck::StaticAssertCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context) {}
 
 void StaticAssertCheck::registerMatchers(MatchFinder *Finder) {
   // This checker only makes sense for languages that have static assertion
   // capabilities: C++11 and C11.
   if (!(getLangOpts().CPlusPlus11 || getLangOpts().C11))
     return;
 
-  auto IsAlwaysFalse = expr(ignoringParenImpCasts(
+  auto IsAlwaysFalse =
       expr(anyOf(cxxBoolLiteral(equals(false)), integerLiteral(equals(0)),
                  cxxNullPtrLiteralExpr(), gnuNullExpr()))
-          .bind("isAlwaysFalse")));
+          .bind("isAlwaysFalse");
   auto IsAlwaysFalseWithCast = ignoringParenImpCasts(anyOf(
-      IsAlwaysFalse, cStyleCastExpr(has(IsAlwaysFalse)).bind("castExpr")));
+      IsAlwaysFalse, cStyleCastExpr(has(ignoringParenImpCasts(IsAlwaysFalse)))
+                         .bind("castExpr")));
   auto AssertExprRoot = anyOf(
       binaryOperator(
           anyOf(hasOperatorName("&&"), hasOperatorName("==")),
           hasEitherOperand(ignoringImpCasts(stringLiteral().bind("assertMSG"))),
           anyOf(binaryOperator(hasEitherOperand(IsAlwaysFalseWithCast)),
                 anything()))
           .bind("assertExprRoot"),
       IsAlwaysFalse);

clang-tidy/misc/SuspiciousMissingCommaCheck.cpp

 }
 
 void SuspiciousMissingCommaCheck::registerMatchers(MatchFinder *Finder) {
   const auto ConcatenatedStringLiteral =
       stringLiteral(isConcatenatedLiteral(MaxConcatenatedTokens)).bind("str");
 
   const auto StringsInitializerList =
       initListExpr(hasType(constantArrayType()),
-                   has(expr(ignoringImpCasts(ConcatenatedStringLiteral))));
+                   has(ignoringParenImpCasts(expr(ConcatenatedStringLiteral))));
 
   Finder->addMatcher(StringsInitializerList.bind("list"), this);
 }
 
 void SuspiciousMissingCommaCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *InitializerList = Result.Nodes.getNodeAs<InitListExpr>("list");
   const auto *ConcatenatedLiteral =

clang-tidy/misc/SuspiciousStringCompareCheck.cpp

Finder->addMatcher(
                        hasOperatorName("||"), hasOperatorName("="))),
           hasEitherOperand(StringCompareCallExpr))
           .bind("suspicious-operator"),
       this);
 
   // Detect comparison to invalid constant: 'strcmp() == -1'.
   const auto InvalidLiteral = ignoringParenImpCasts(
       anyOf(integerLiteral(unless(equals(0))),
-            unaryOperator(hasOperatorName("-"),
-                          has(integerLiteral(unless(equals(0))))),
+            unaryOperator(
+                hasOperatorName("-"),
+                has(ignoringParenImpCasts(integerLiteral(unless(equals(0)))))),
             characterLiteral(), cxxBoolLiteral()));
 
   Finder->addMatcher(binaryOperator(matchers::isComparisonOperator(),
                                     hasEitherOperand(StringCompareCallExpr),
                                     hasEitherOperand(InvalidLiteral))
                          .bind("invalid-comparison"),
                      this);
 }

clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp

Finder->addMatcher(
                     hasParameter(0, parmVarDecl(hasType(BadSelf))))
           .bind("ArgumentType"),
       this);
 
   Finder->addMatcher(
       cxxMethodDecl(IsSelfAssign, anyOf(isConst(), isVirtual())).bind("cv"),
       this);
 
-  const auto IsBadReturnStatement = returnStmt(unless(has(
-      unaryOperator(hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())))));
+  const auto IsBadReturnStatement = returnStmt(unless(has(ignoringParenImpCasts(
+      unaryOperator(hasOperatorName("*"), hasUnaryOperand(cxxThisExpr()))))));
   const auto IsGoodAssign = cxxMethodDecl(IsAssign, HasGoodReturnType);
 
   Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))
                          .bind("returnStmt"),
                      this);
 }
 
 void UnconventionalAssignOperatorCheck::check(const MatchFinder::MatchResult &Result) {

clang-tidy/misc/UniqueptrResetReleaseCheck.cpp

void UniqueptrResetReleaseCheck::registerMatchers(MatchFinder *Finder) {
 
   Finder->addMatcher(
       cxxMemberCallExpr(
           on(expr().bind("left")), callee(memberExpr().bind("reset_member")),
           callee(
               cxxMethodDecl(hasName("reset"),
                             ofClass(cxxRecordDecl(hasName("::std::unique_ptr"),
                                                   decl().bind("left_class"))))),
-          has(cxxMemberCallExpr(
+          has(ignoringParenImpCasts(cxxMemberCallExpr(
               on(expr().bind("right")),
               callee(memberExpr().bind("release_member")),
               callee(cxxMethodDecl(
                   hasName("release"),
                   ofClass(cxxRecordDecl(hasName("::std::unique_ptr"),
-                                        decl().bind("right_class"))))))))
+                                        decl().bind("right_class")))))))))
           .bind("reset_call"),
       this);
 }
 
 namespace {
 const Type *getDeleterForUniquePtr(const MatchFinder::MatchResult &Result,
                                    StringRef ID) {
   const auto *Class =

clang-tidy/misc/UnusedRAIICheck.cpp

void UnusedRAIICheck::registerMatchers(MatchFinder *Finder) {
   // Only register the matchers for C++; the functionality currently does not
   // provide any benefit to other languages, despite being benign.
   if (!getLangOpts().CPlusPlus)
     return;
 
   // Look for temporaries that are constructed in-place and immediately
   // destroyed. Look for temporaries created by a functional cast but not for
   // those returned from a call.
-  auto BindTemp = cxxBindTemporaryExpr(unless(has(callExpr()))).bind("temp");
+  auto BindTemp =
+      cxxBindTemporaryExpr(unless(has(ignoringParenImpCasts(callExpr()))))
+          .bind("temp");
   Finder->addMatcher(
-      exprWithCleanups(
-          unless(isInTemplateInstantiation()),
+      exprWithCleanups(unless(isInTemplateInstantiation()),
                        hasParent(compoundStmt().bind("compound")),
                        hasType(cxxRecordDecl(hasNonTrivialDestructor())),
-          anyOf(has(BindTemp), has(cxxFunctionalCastExpr(has(BindTemp)))))
+                       anyOf(has(ignoringParenImpCasts(BindTemp)),
+                             has(ignoringParenImpCasts(cxxFunctionalCastExpr(
+                                 has(ignoringParenImpCasts(BindTemp)))))))
           .bind("expr"),
       this);
 }
 
 void UnusedRAIICheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getStmtAs<Expr>("expr");
 
   // We ignore code expanded from macros to reduce the number of false

clang-tidy/modernize/MakeSmartPtrCheck.cpp

MakeSmartPtrCheck::MakeSmartPtrCheck(StringRef Name, ClangTidyContext *Context,
     : ClangTidyCheck(Name, Context),
       makeSmartPtrFunctionName(std::move(makeSmartPtrFunctionName)) {}
 
 void MakeSmartPtrCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus11)
     return;
 
   Finder->addMatcher(
-      cxxBindTemporaryExpr(
-          has(cxxConstructExpr(
-                  hasType(getSmartPointerTypeMatcher()), argumentCountIs(1),
-                  hasArgument(
-                      0, cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType(
+      cxxBindTemporaryExpr(has(ignoringParenImpCasts(
+          cxxConstructExpr(
+              hasArgument(0,
+                          cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType(
                                          equalsBoundNode(PointerType))))))
                               .bind(NewExpression)))
-                  .bind(ConstructorCall))),
+              .bind(ConstructorCall)))),
       this);
 }
 
 void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) {
   // 'smart_ptr' refers to 'std::shared_ptr' or 'std::unique_ptr' or other
   // pointer, 'make_smart_ptr' refers to 'std::make_shared' or
   // 'std::make_unique' or other function that creates smart_ptr.
 

clang-tidy/modernize/PassByValueCheck.cpp

Finder->addMatcher(
       cxxConstructorDecl(
           forEachConstructorInitializer(
               cxxCtorInitializer(
                   // Clang builds a CXXConstructExpr only whin it knows which
                   // constructor will be called. In dependent contexts a
                   // ParenListExpr is generated instead of a CXXConstructExpr,
                   // filtering out templates automatically for us.
                   withInitializer(cxxConstructExpr(
-                      has(declRefExpr(to(
+                      has(ignoringParenImpCasts(declRefExpr(to(
                           parmVarDecl(
                               hasType(qualType(
                                   // Match only const-ref or a non-const value
                                   // parameters. Rvalues and const-values
                                   // shouldn't be modified.
                                   anyOf(constRefType(), nonConstValueType()))))
-                              .bind("Param")))),
+                              .bind("Param"))))),
                       hasDeclaration(cxxConstructorDecl(
                           isCopyConstructor(), unless(isDeleted()),
                           hasDeclContext(
                               cxxRecordDecl(isMoveConstructible())))))))
                   .bind("Initializer")))
           .bind("Ctor"),
       this);
 }

clang-tidy/modernize/ShrinkToFitCheck.cpp

 
 void ShrinkToFitCheck::registerMatchers(MatchFinder *Finder) {
   // Swap as a function need not to be considered, because rvalue can not
   // be bound to a non-const reference.
   const auto ShrinkableAsMember =
       memberExpr(member(valueDecl().bind("ContainerDecl")));
   const auto ShrinkableAsDecl =
       declRefExpr(hasDeclaration(valueDecl().bind("ContainerDecl")));
-  const auto CopyCtorCall = cxxConstructExpr(
-      hasArgument(0, anyOf(ShrinkableAsMember, ShrinkableAsDecl,
-                           unaryOperator(has(ShrinkableAsMember)),
-                           unaryOperator(has(ShrinkableAsDecl)))));
-  const auto SwapParam = expr(anyOf(
-      memberExpr(member(equalsBoundNode("ContainerDecl"))),
+  const auto CopyCtorCall = cxxConstructExpr(hasArgument(
+      0, anyOf(ShrinkableAsMember, ShrinkableAsDecl,
+               unaryOperator(has(ignoringParenImpCasts(ShrinkableAsMember))),
+               unaryOperator(has(ignoringParenImpCasts(ShrinkableAsDecl))))));
+  const auto SwapParam =
+      expr(anyOf(memberExpr(member(equalsBoundNode("ContainerDecl"))),
                  declRefExpr(hasDeclaration(equalsBoundNode("ContainerDecl"))),
-      unaryOperator(has(memberExpr(member(equalsBoundNode("ContainerDecl"))))),
-      unaryOperator(
-          has(declRefExpr(hasDeclaration(equalsBoundNode("ContainerDecl")))))));
+                 unaryOperator(has(ignoringParenImpCasts(
+                     memberExpr(member(equalsBoundNode("ContainerDecl")))))),
+                 unaryOperator(has(ignoringParenImpCasts(declRefExpr(
+                     hasDeclaration(equalsBoundNode("ContainerDecl"))))))));
 
   Finder->addMatcher(
-      cxxMemberCallExpr(on(hasType(namedDecl(
+      cxxMemberCallExpr(
+          on(hasType(namedDecl(
               hasAnyName("std::basic_string", "std::deque", "std::vector")))),
-                        callee(cxxMethodDecl(hasName("swap"))),
-                        has(memberExpr(hasDescendant(CopyCtorCall))),
-                        hasArgument(0, SwapParam.bind("ContainerToShrink")),
-                        unless(isInTemplateInstantiation()))
+          has(ignoringParenImpCasts(memberExpr(hasDescendant(CopyCtorCall)))),
           .bind("CopyAndSwapTrick"),
       this);
 }
 
 void ShrinkToFitCheck::check(const MatchFinder::MatchResult &Result) {
   const LangOptions &Opts = Result.Context->getLangOpts();
 
   if (!Opts.CPlusPlus11)

clang-tidy/modernize/UseBoolLiteralsCheck.cpp

 namespace modernize {
 
 void UseBoolLiteralsCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(
       implicitCastExpr(
-          has(integerLiteral().bind("literal")),
+          has(ignoringParenImpCasts(integerLiteral().bind("literal"))),
           hasImplicitDestinationType(qualType(booleanType())),
           unless(isInTemplateInstantiation()),
           anyOf(hasParent(explicitCastExpr().bind("cast")), anything())),
       this);
 }
 
 void UseBoolLiteralsCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Literal = Result.Nodes.getNodeAs<IntegerLiteral>("literal");

clang-tidy/modernize/UseDefaultCheck.cpp

static bool isCopyAssignmentAndCanBeDefaulted(ASTContext *Context,
   auto FieldsToInit = getAllNamedFields(Record);
 
   const auto *Compound = cast<CompoundStmt>(Operator->getBody());
 
   // The assignment operator definition has to end with the following return
   // statement:
   //   return *this;
   if (Compound->body_empty() ||
-      match(returnStmt(has(unaryOperator(hasOperatorName("*"),
-                                         hasUnaryOperand(cxxThisExpr())))),
+      match(returnStmt(has(ignoringParenImpCasts(unaryOperator(
+                hasOperatorName("*"), hasUnaryOperand(cxxThisExpr()))))),
             *Compound->body_back(), *Context)
           .empty())
     return false;
 
   // Ensure that all the bases are copied.
   for (const auto *Base : BasesToInit) {
     // Assignment operator of a base class:
     //   Base::operator=(Other);
     //
     // Clang translates this into:
     //   ((Base*)this)->operator=((Base)Other);
     //
     // So we are looking for a member call that fulfills:
-    if (match(
-            compoundStmt(has(cxxMemberCallExpr(allOf(
+    if (match(compoundStmt(has(ignoringParenImpCasts(cxxMemberCallExpr(allOf(
                   // - The object is an implicit cast of 'this' to a pointer to
                   //   a base class.
                   onImplicitObjectArgument(
                       implicitCastExpr(hasImplicitDestinationType(
                                            pointsTo(type(equalsNode(Base)))),
                                        hasSourceExpression(cxxThisExpr()))),
                   // - The called method is the operator=.
                   callee(cxxMethodDecl(isCopyAssignmentOperator())),
                   // - The argument is (an implicit cast to a Base of) the
                   // argument taken by "Operator".
                   argumentCountIs(1),
-                hasArgument(0, declRefExpr(to(varDecl(equalsNode(Param))))))))),
+                  hasArgument(0,
+                              declRefExpr(to(varDecl(equalsNode(Param)))))))))),
               *Compound, *Context)
             .empty())
       return false;
   }
 
   // Ensure that all the members are copied.
   for (const auto *Field : FieldsToInit) {
     // The assignment of data members:
     //   Field = Other.Field;
     // Is a BinaryOperator in non-class types, and a CXXOperatorCallExpr
     // otherwise.
     auto LHS = memberExpr(hasObjectExpression(cxxThisExpr()),
                           member(fieldDecl(equalsNode(Field))));
     auto RHS = accessToFieldInVar(Field, Param);
     if (match(
-            compoundStmt(has(stmt(anyOf(
+            compoundStmt(has(ignoringParenImpCasts(stmt(anyOf(
                 binaryOperator(hasOperatorName("="), hasLHS(LHS), hasRHS(RHS)),
                 cxxOperatorCallExpr(hasOverloadedOperatorName("="),
                                     argumentCountIs(2), hasArgument(0, LHS),
-                                    hasArgument(1, RHS)))))),
+                                    hasArgument(1, RHS))))))),
             *Compound, *Context)
             .empty())
       return false;
   }
 
   // Ensure that we don't do anything else.
   return Compound->size() == BasesToInit.size() + FieldsToInit.size() + 1;
 }

clang-tidy/readability/SimplifyBooleanExprCheck.cpp

 
 void SimplifyBooleanExprCheck::matchCompoundIfReturnsBool(MatchFinder *Finder,
                                                           bool Value,
                                                           StringRef Id) {
   Finder->addMatcher(
       compoundStmt(allOf(hasAnySubstatement(ifStmt(hasThen(returnsBool(Value)),
                                                    unless(hasElse(stmt())))),
                          hasAnySubstatement(
-                             returnStmt(has(cxxBoolLiteral(equals(!Value))))
+                             returnStmt(has(ignoringParenImpCasts(
+                                            cxxBoolLiteral(equals(!Value)))))
                                  .bind(CompoundReturnId))))
           .bind(Id),
       this);
 }
 
 void SimplifyBooleanExprCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "ChainedConditionalReturn", ChainedConditionalReturn);
   Options.store(Opts, "ChainedConditionalAssignment",

clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp

auto IsSusbstituted = qualType(anyOf(
       substTemplateTypeParmType(), hasDescendant(substTemplateTypeParmType())));
 
   auto UniquePtrWithDefaultDelete = classTemplateSpecializationDecl(
       hasName("std::unique_ptr"),
       hasTemplateArgument(1, refersToType(qualType(hasDeclaration(cxxRecordDecl(
                                  hasName("std::default_delete")))))));
 
   Finder->addMatcher(
-      cxxDeleteExpr(
-          has(cxxMemberCallExpr(on(expr(hasType(UniquePtrWithDefaultDelete),
-                                        unless(hasType(IsSusbstituted)))
-                                       .bind("uptr")),
-                                callee(cxxMethodDecl(hasName("release"))))))
+      cxxDeleteExpr(has(ignoringParenImpCasts(cxxMemberCallExpr(
+                        on(expr(hasType(UniquePtrWithDefaultDelete),
+                        callee(cxxMethodDecl(hasName("release")))))))
           .bind("delete"),
       this);
 }
 
 void UniqueptrDeleteReleaseCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *PtrExpr = Result.Nodes.getNodeAs<Expr>("uptr");
   const auto *DeleteExpr = Result.Nodes.getNodeAs<Expr>("delete");

docs/ReleaseNotes.rst

 Clang. If upgrading an external codebase that uses Clang as a library,
 this section should help get you past the largest hurdles of upgrading.
 
 -  ...
 
 AST Matchers
 ------------
 
-- hasAnyArgument: Matcher no longer ignores parentheses and implicit casts on
-  the argument before applying the inner matcher. The fix was done to allow for
-  greater control by the user. In all existing checkers that use this matcher
-  all instances of code ``hasAnyArgument(<inner matcher>)`` must be changed to
-  ``hasAnyArgument(ignoringParenImpCasts(<inner matcher>))``.
+- has and hasAnyArgument: Matchers no longer ignores parentheses and implicit
+  casts on the argument before applying the inner matcher. The fix was done to
+  allow for greater control by the user. In all existing checkers that use this
+  matcher all instances of code ``hasAnyArgument(<inner matcher>)`` or
+  ``has(<inner matcher>)`` must be changed to
+  ``hasAnyArgument(ignoringParenImpCasts(<inner matcher>))`` or
+  ``has(ignoringParenImpCasts(<inner matcher>))``.
 
 ...
 
 libclang
 --------
 
 ...
 

include/clang/ASTMatchers/ASTMatchers.h

 ///   class X {};  // Matches X, because X::X is a class of name X inside X.
 ///   class Y { class X {}; };
 ///   class Z { class Y { class X {}; }; };  // Does not match Z.
 /// \endcode
 ///
 /// ChildT must be an AST base type.
 ///
 /// Usable as: Any Matcher
+/// Note that has is direct matcher, so it also matches things like implicit
+/// casts and paren casts. If you are matching with expr then you should
+/// probably consider using ignoringParenImpCasts like:
+/// has(ignoringParenImpCasts(expr())).
 const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher>
 LLVM_ATTRIBUTE_UNUSED has = {};
 
 /// \brief Matches AST nodes that have descendant AST nodes that match the
 /// provided matcher.
 ///
 /// Example matches X, Y, Z
 ///     (matcher = cxxRecordDecl(hasDescendant(cxxRecordDecl(hasName("X")))))

include/clang/ASTMatchers/ASTMatchersInternal.h

 };
 
 /// \brief Matches nodes of type T that have child nodes of type ChildT for
 /// which a specified child matcher matches.
 ///
 /// ChildT must be an AST base type.
 template <typename T, typename ChildT>
 class HasMatcher : public WrapperMatcherInterface<T> {
-  static_assert(IsBaseType<ChildT>::value,
-                "has only accepts base type matcher");
 
 public:
   explicit HasMatcher(const Matcher<ChildT> &ChildMatcher)
       : HasMatcher::WrapperMatcherInterface(ChildMatcher) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
-    return Finder->matchesChildOf(
-        Node, this->InnerMatcher, Builder,
-        ASTMatchFinder::TK_IgnoreImplicitCastsAndParentheses,
-        ASTMatchFinder::BK_First);
+    return Finder->matchesChildOf(Node, this->InnerMatcher, Builder,
+                                  ASTMatchFinder::TK_AsIs,
+                                  ASTMatchFinder::BK_First);
   }
 };
 
 /// \brief Matches nodes of type T that have child nodes of type ChildT for
 /// which a specified child matcher matches. ChildT must be an AST base
 /// type.
 /// As opposed to the HasMatcher, the ForEachMatcher will produce a match
 /// for each child that matches.

include/clang/CMakeLists.txt

 add_subdirectory(AST)
 add_subdirectory(Basic)
 add_subdirectory(Driver)
 add_subdirectory(Parse)
 add_subdirectory(Sema)
 add_subdirectory(Serialization)
 add_subdirectory(StaticAnalyzer/Checkers)
+add_subdirectory(ASTMatchers)

unittests/AST/ASTImporterTest.cpp

EXPECT_TRUE(
                            has(
                              cxxThisExpr(
                                hasType(
                                  asString("class declToImport *"))))))))));
 }
 
 TEST(ImportExpr, ImportAtomicExpr) {
   MatchVerifier<Decl> Verifier;
-  EXPECT_TRUE(
-        testImport(
-          "void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }",
-          Lang_CXX, "", Lang_CXX, Verifier,
-          functionDecl(
-            hasBody(
-              compoundStmt(
-                has(
-                  atomicExpr(
-                    has(declRefExpr(
-                          hasDeclaration(varDecl(hasName("ptr"))),
-                          hasType(asString("int *")))),
-                    has(integerLiteral(equals(1), hasType(asString("int"))))
-                    )))))));
+  EXPECT_TRUE(testImport(
+      "void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }", Lang_CXX,
+      "", Lang_CXX, Verifier,
+      functionDecl(hasBody(compoundStmt(has(atomicExpr(
+          has(ignoringParenImpCasts(
+              declRefExpr(hasDeclaration(varDecl(hasName("ptr"))),
+                          hasType(asString("int *"))))),
+          has(integerLiteral(equals(1), hasType(asString("int")))))))))));
 }
 
 TEST(ImportExpr, ImportLabelDeclAndAddrLabelExpr) {
   MatchVerifier<Decl> Verifier;
   EXPECT_TRUE(
         testImport(
           "void declToImport() { loop: goto loop; &&loop; }",
           Lang_CXX, "", Lang_CXX, Verifier,

unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

EXPECT_TRUE(matches(
     varDecl(hasName("i"), hasType(qualType(has(builtinType()))))));
   EXPECT_TRUE(notMatches(
     "int* i;",
     varDecl(hasName("i"), hasType(qualType(has(pointerType()))))));
 }
 
 TEST(StatementMatcher, Has) {
   StatementMatcher HasVariableI =
       expr(hasType(pointsTo(recordDecl(hasName("X")))),
-         has(declRefExpr(to(varDecl(hasName("i"))))));
+           has(ignoringParenImpCasts(declRefExpr(to(varDecl(hasName("i")))))));
 
   EXPECT_TRUE(matches(
     "class X; X *x(int); void c() { int i; x(i); }", HasVariableI));
   EXPECT_TRUE(notMatches(
     "class X; X *x(int); void c() { int i; x(42); }", HasVariableI));
 }
 
 TEST(StatementMatcher, HasDescendant) {