[clang-tidy] Cleanup some ast-matchers and lift some to utils.

[etienneb]

Summary

Little cleanup to lift-out and to remove some frequently used
ast-matchers.

Some of theses matchers are candidates to be lifted to ASTMatchers.h.

[alexfh]

Looks good! Thank you for the cleanup!

[etienneb]

rebased, merge: D19262

clang-tidy/misc/BoolPointerImplicitConversionCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace {
 
 AST_MATCHER(CastExpr, isPointerToBoolean) {
   return Node.getCastKind() == CK_PointerToBoolean;
 }
-AST_MATCHER(QualType, isBoolean) { return Node->isBooleanType(); }
 
 } // namespace
 
 namespace tidy {
 namespace misc {
 
 void BoolPointerImplicitConversionCheck::registerMatchers(MatchFinder *Finder) {
   // Look for ifs that have an implicit bool* to bool conversion in the
   // condition. Filter negations.
   Finder->addMatcher(
       ifStmt(hasCondition(findAll(implicitCastExpr(
                  allOf(unless(hasParent(unaryOperator(hasOperatorName("!")))),
                        hasSourceExpression(expr(
-                           hasType(pointerType(pointee(isBoolean()))),
+                           hasType(pointerType(pointee(booleanType()))),
                            ignoringParenImpCasts(declRefExpr().bind("expr")))),
                        isPointerToBoolean())))),
              unless(isInTemplateInstantiation())).bind("if"),
       this);
 }
 
 void BoolPointerImplicitConversionCheck::check(
     const MatchFinder::MatchResult &Result) {

clang-tidy/misc/IncorrectRoundings.cpp

 AST_MATCHER(FloatingLiteral, floatHalf) {
   const auto &literal = Node.getValue();
   if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle)
     return literal.convertToFloat() == 0.5f;
   if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble)
     return literal.convertToDouble() == 0.5;
   return false;
 }
-
-// TODO(hokein): Moving it to ASTMatchers.h
-AST_MATCHER(BuiltinType, isFloatingPoint) {
-  return Node.isFloatingPoint();
-}
 } // namespace ast_matchers
 } // namespace clang
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 void IncorrectRoundings::registerMatchers(MatchFinder *MatchFinder) {
   // Match a floating literal with value 0.5.
   auto FloatHalf = floatLiteral(floatHalf());
 
   // Match a floating point expression.
-  auto FloatType = expr(hasType(builtinType(isFloatingPoint())));
+  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)));
 
   // 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.

clang-tidy/misc/MacroParenthesesCheck.cpp

 #include "clang/Lex/Preprocessor.h"
 
 namespace clang {
 namespace tidy {
 
 namespace {
 class MacroParenthesesPPCallbacks : public PPCallbacks {
 public:
-  explicit MacroParenthesesPPCallbacks(Preprocessor *PP,
-                                       MacroParenthesesCheck *Check)
+  MacroParenthesesPPCallbacks(Preprocessor *PP,
       : PP(PP), Check(Check) {}
 
   void MacroDefined(const Token &MacroNameTok,
                     const MacroDirective *MD) override {
     replacementList(MacroNameTok, MD->getMacroInfo());
     argument(MacroNameTok, MD->getMacroInfo());
   }
 

clang-tidy/misc/MisplacedWideningCastCheck.cpp

 //===--- MisplacedWideningCastCheck.cpp - clang-tidy-----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MisplacedWideningCastCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "../utils/Matchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 MisplacedWideningCastCheck::MisplacedWideningCastCheck(
const auto ImplicitCast =
       implicitCastExpr(hasImplicitDestinationType(isInteger()), has(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(anyOf(hasOperatorName("=="), hasOperatorName("!="),
-                           hasOperatorName("<"), hasOperatorName("<="),
-                           hasOperatorName(">"), hasOperatorName(">=")),
+      binaryOperator(matchers::isComparisonOperator(),
                      hasEitherOperand(Cast)),
       this);
 }
 
 static unsigned getMaxCalculationWidth(const ASTContext &Context,
                                        const Expr *E) {
   E = E->IgnoreParenImpCasts();
 

clang-tidy/misc/PointerAndIntegralOperationCheck.cpp

 //===--- PointerAndIntegralOperationCheck.cpp - clang-tidy-----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PointerAndIntegralOperationCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "../utils/Matchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 void PointerAndIntegralOperationCheck::registerMatchers(MatchFinder *Finder) {
   const auto PointerExpr = expr(hasType(pointerType()));
   const auto BoolExpr = ignoringParenImpCasts(hasType(booleanType()));
   const auto CharExpr = ignoringParenImpCasts(hasType(isAnyCharacter()));
 
   const auto BinOpWithPointerExpr =
       binaryOperator(unless(anyOf(hasOperatorName(","), hasOperatorName("="))),
                      hasEitherOperand(PointerExpr));
 
   const auto AssignToPointerExpr =
       binaryOperator(hasOperatorName("="), hasLHS(PointerExpr));
 
   const auto CompareToPointerExpr =
-      binaryOperator(anyOf(hasOperatorName("<"), hasOperatorName("<="),
-                           hasOperatorName(">"), hasOperatorName(">=")),
+      binaryOperator(matchers::isRelationalOperator(),
                      hasEitherOperand(PointerExpr));
 
   // Detect expression like: ptr = (x != y);
   Finder->addMatcher(binaryOperator(AssignToPointerExpr, hasRHS(BoolExpr))
                          .bind("assign-bool-to-pointer"),
                      this);
 
   // Detect expression like: ptr = A[i]; where A is char*.

clang-tidy/misc/SizeofExpressionCheck.cpp

 //===--- SizeofExpressionCheck.cpp - clang-tidy----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SizeofExpressionCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "../utils/Matchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 namespace {
 
-AST_MATCHER(BinaryOperator, isRelationalOperator) {
-  return Node.isRelationalOp();
-}
-
 AST_MATCHER_P(IntegerLiteral, isBiggerThan, unsigned, N) {
   return Node.getValue().getZExtValue() > N;
 }
 
 AST_MATCHER_P2(Expr, hasSizeOfDescendant, int, Depth,
                ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
   if (Depth < 0)
     return false;
Finder->addMatcher(
       expr(sizeOfExpr(has(expr(ignoringParenImpCasts(
                anyOf(ArrayCastExpr, PointerToArrayExpr, StructAddrOfExpr))))))
           .bind("sizeof-pointer-to-aggregate"),
       this);
 
   // Detect expression like: sizeof(epxr) <= k for a suspicious constant 'k'.
   if (WarnOnSizeOfCompareToConstant) {
     Finder->addMatcher(
-        binaryOperator(isRelationalOperator(),
+        binaryOperator(matchers::isRelationalOperator(),
                        hasEitherOperand(ignoringParenImpCasts(SizeOfExpr)),
                        hasEitherOperand(ignoringParenImpCasts(
                            anyOf(integerLiteral(equals(0)),
                                  integerLiteral(isBiggerThan(0x80000))))))
             .bind("sizeof-compare-constant"),
         this);
   }
 

clang-tidy/modernize/ShrinkToFitCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/StringRef.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
-namespace {
-bool isShrinkableContainer(llvm::StringRef ClassName) {
-  static const char *const Shrinkables[] = {
-    "std::basic_string",
-    "std::deque",
-    "std::vector"
-  };
-  return std::binary_search(std::begin(Shrinkables), std::end(Shrinkables),
-                            ClassName);
-}
-
-AST_MATCHER(NamedDecl, stlShrinkableContainer) {
-  return isShrinkableContainer(Node.getQualifiedNameAsString());
-}
-} // namespace
-
 namespace tidy {
 namespace modernize {
 
 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"))),
       declRefExpr(hasDeclaration(equalsBoundNode("ContainerDecl"))),
       unaryOperator(has(memberExpr(member(equalsBoundNode("ContainerDecl"))))),
       unaryOperator(
           has(declRefExpr(hasDeclaration(equalsBoundNode("ContainerDecl")))))));
 
   Finder->addMatcher(
-      cxxMemberCallExpr(on(hasType(namedDecl(stlShrinkableContainer()))),
+      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()))
           .bind("CopyAndSwapTrick"),
       this);
 }
 

clang-tidy/readability/ContainerSizeEmptyCheck.cpp

 //===--- ContainerSizeEmptyCheck.cpp - clang-tidy -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "ContainerSizeEmptyCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/StringRef.h"
+#include "../utils/Matchers.h"
 
 using namespace clang::ast_matchers;
 
-static bool isContainerName(llvm::StringRef ClassName) {
-  static const char *const ContainerNames[] = {"array",
-                                               "basic_string",
-                                               "deque",
-                                               "forward_list",
-                                               "list",
-                                               "map",
-                                               "multimap",
-                                               "multiset",
-                                               "priority_queue",
-                                               "queue",
-                                               "set",
-                                               "stack",
-                                               "unordered_map",
-                                               "unordered_multimap",
-                                               "unordered_multiset",
-                                               "unordered_set",
-                                               "vector"};
-  return std::binary_search(std::begin(ContainerNames),
-                            std::end(ContainerNames), ClassName);
-}
-
 namespace clang {
-namespace {
-AST_MATCHER(NamedDecl, stlContainer) {
-  if (!isContainerName(Node.getName()))
-    return false;
-
-  return StringRef(Node.getQualifiedNameAsString()).startswith("std::");
-}
-} // namespace
-
 namespace tidy {
 namespace readability {
 
 ContainerSizeEmptyCheck::ContainerSizeEmptyCheck(StringRef Name,
                                                  ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context) {}
 
 void ContainerSizeEmptyCheck::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 stlContainer = hasAnyName(
+      "array", "basic_string", "deque", "forward_list", "list", "map",
+      "multimap", "multiset", "priority_queue", "queue", "set", "stack",
+      "unordered_map", "unordered_multimap", "unordered_multiset",
+      "unordered_set", "vector");
+
   const auto WrongUse = anyOf(
       hasParent(binaryOperator(
-                    anyOf(hasOperatorName("<"), hasOperatorName(">="),
-                          hasOperatorName(">"), hasOperatorName("<="),
-                          hasOperatorName("=="), hasOperatorName("!=")),
+                    matchers::isComparisonOperator(),
                     hasEitherOperand(ignoringImpCasts(anyOf(
                         integerLiteral(equals(1)), integerLiteral(equals(0))))))
                     .bind("SizeBinaryOp")),
       hasParent(implicitCastExpr(
           hasImplicitDestinationType(booleanType()),
           anyOf(
               hasParent(unaryOperator(hasOperatorName("!")).bind("NegOnSize")),
               anything()))),
       hasParent(explicitCastExpr(hasDestinationType(booleanType()))));
 
   Finder->addMatcher(
       cxxMemberCallExpr(
-          on(expr(anyOf(hasType(namedDecl(stlContainer())),
-                        hasType(pointsTo(namedDecl(stlContainer()))),
-                        hasType(references(namedDecl(stlContainer())))))
+          on(expr(anyOf(hasType(namedDecl(stlContainer)),
+                        hasType(pointsTo(namedDecl(stlContainer))),
+                        hasType(references(namedDecl(stlContainer)))))
                  .bind("STLObject")),
           callee(cxxMethodDecl(hasName("size"))), WrongUse)
           .bind("SizeCallExpr"),
       this);
 }
 
 void ContainerSizeEmptyCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MemberCall =

clang-tidy/readability/ImplicitBoolCastCheck.cpp

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 
 namespace {
 
-const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr;
-
 AST_MATCHER_P(CastExpr, hasCastKind, CastKind, Kind) {
   return Node.getCastKind() == Kind;
 }
 
-AST_MATCHER(QualType, isBool) {
-  return !Node.isNull() && Node->isBooleanType();
-}
-
 AST_MATCHER(Stmt, isMacroExpansion) {
   SourceManager &SM = Finder->getASTContext().getSourceManager();
   SourceLocation Loc = Node.getLocStart();
   return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc);
 }
 
 bool isNULLMacroExpansion(const Stmt *Statement, ASTContext &Context) {
   SourceManager &SM = Context.getSourceManager();

 StatementMatcher createImplicitCastFromBoolMatcher() {
   return implicitCastExpr(
       unless(createExceptionCasesMatcher()),
       anyOf(hasCastKind(CK_IntegralCast), hasCastKind(CK_IntegralToFloating),
             // Prior to C++11 cast from bool literal to pointer was allowed.
             allOf(anyOf(hasCastKind(CK_NullToPointer),
                         hasCastKind(CK_NullToMemberPointer)),
                   hasSourceExpression(cxxBoolLiteral()))),
-      hasSourceExpression(expr(hasType(qualType(isBool())))));
+      hasSourceExpression(expr(hasType(qualType(booleanType())))));
 }
 
 StringRef
 getZeroLiteralToCompareWithForGivenType(CastKind CastExpressionKind,
                                         QualType CastSubExpressionType,
                                         ASTContext &Context) {
   switch (CastExpressionKind) {
   case CK_IntegralToBoolean:

clang-tidy/utils/Matchers.h

 
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "TypeTraits.h"
 
 namespace clang {
 namespace tidy {
 namespace matchers {
 
+AST_MATCHER(BinaryOperator, isRelationalOperator) {
+  return Node.isRelationalOp();
+}
+
+AST_MATCHER(BinaryOperator, isEqualityOperator) {
+  return Node.isEqualityOp();
+}
+
+AST_MATCHER(BinaryOperator, isComparisonOperator) {
+  return Node.isComparisonOp();
+}
+
 AST_MATCHER(QualType, isExpensiveToCopy) {
   llvm::Optional<bool> IsExpensive =
       type_traits::isExpensiveToCopy(Node, Finder->getASTContext());
   return IsExpensive && *IsExpensive;
 }
 
 AST_MATCHER(RecordDecl, isTriviallyDefaultConstructible) {
   return type_traits::recordIsTriviallyDefaultConstructible(
       Node, Finder->getASTContext());
 }
 
 } // namespace matchers
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_MATCHERS_H