[clang-tidy] Lift common matchers to utils namespace

[etienneb]

Summary

This patch is lifting matchers used by more than one checkers
to the common namespace.

[alexfh]

clang-tidy/utils/Matchers.h

20

All these should go to ASTMatchers.h (with tests and documentation).

[etienneb]

Who is the owner of ASTMatcher?

If he is willing to receive these matchers in ASTMatcher, I'll lift them.
Otherwise, we should at least lift them within clang-tidy.

[alexfh]

In D19841#419488, @etienneb wrote:

Who is the owner of ASTMatcher?

If he is willing to receive these matchers in ASTMatcher, I'll lift them.
Otherwise, we should at least lift them within clang-tidy.

Send a patch to sbenza or klimek. I think, these matchers are generic enough to be useful in the core matchers library.

[etienneb]

rebase over trunk. matchers are lifted to ASTMatchers.

[etienneb]

nits: indent

[aaron.ballman]

LGTM!

[alexfh]

LG. Thank you!

clang-tidy/utils/Matchers.h

20

Consider moving this to ASTMatchers.h in a follow-up.

[aaron.ballman]

clang-tidy/utils/Matchers.h

20

Honestly, this one is a lot less interesting as a public AST matcher. I would avoid that unless there's a really solid case for it.

clang-tidy/misc/BoolPointerImplicitConversionCheck.cpp

 #include "BoolPointerImplicitConversionCheck.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
-namespace {
-
-AST_MATCHER(CastExpr, isPointerToBoolean) {
-  return Node.getCastKind() == CK_PointerToBoolean;
-}
-
-} // namespace
-
 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(booleanType()))),
                            ignoringParenImpCasts(declRefExpr().bind("expr")))),
-                       isPointerToBoolean())))),
+                       hasCastKind(CK_PointerToBoolean))))),
              unless(isInTemplateInstantiation())).bind("if"),
       this);
 }
 
 void BoolPointerImplicitConversionCheck::check(
     const MatchFinder::MatchResult &Result) {
   auto *If = Result.Nodes.getStmtAs<IfStmt>("if");
   auto *Var = Result.Nodes.getStmtAs<DeclRefExpr>("expr");

clang-tidy/modernize/UseNullptrCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace modernize {
 namespace {
 
 const char CastSequence[] = "sequence";
 
-/// \brief Matches cast expressions that have a cast kind of CK_NullToPointer
-/// or CK_NullToMemberPointer.
-///
-/// Given
-/// \code
-///   int *p = 0;
-/// \endcode
-/// implicitCastExpr(isNullToPointer()) matches the implicit cast clang adds
-/// around \c 0.
-AST_MATCHER(CastExpr, isNullToPointer) {
-  return Node.getCastKind() == CK_NullToPointer ||
-         Node.getCastKind() == CK_NullToMemberPointer;
-}
-
 AST_MATCHER(Type, sugaredNullptrType) {
   const Type *DesugaredType = Node.getUnqualifiedDesugaredType();
   if (const BuiltinType *BT = dyn_cast<BuiltinType>(DesugaredType))
     return BT->getKind() == BuiltinType::NullPtr;
   return false;
 }
 
 /// \brief Create a matcher that finds implicit casts as well as the head of a
 /// sequence of zero or more nested explicit casts that have an implicit cast
 /// to null within.
 /// Finding sequences of explict casts is necessary so that an entire sequence
 /// can be replaced instead of just the inner-most implicit cast.
 StatementMatcher makeCastSequenceMatcher() {
   StatementMatcher ImplicitCastToNull = implicitCastExpr(
-      isNullToPointer(),
+      anyOf(hasCastKind(CK_NullToPointer),
+            hasCastKind(CK_NullToMemberPointer)),
       unless(hasSourceExpression(hasType(sugaredNullptrType()))));
 
   return castExpr(anyOf(ImplicitCastToNull,
                         explicitCastExpr(hasDescendant(ImplicitCastToNull))),
                   unless(hasAncestor(explicitCastExpr())))
       .bind(CastSequence);
 }
 

clang-tidy/performance/FasterStringFindCheck.cpp

llvm::Optional<std::string> MakeCharacterLiteral(const StringLiteral *Literal) {
   if (pos == Result.npos) return llvm::None;
   Result[pos] = '\'';
   pos = Result.find_last_of('"');
   if (pos == Result.npos) return llvm::None;
   Result[pos] = '\'';
   return Result;
 }
 
-AST_MATCHER(StringLiteral, lengthIsOne) { return Node.getLength() == 1; }
-
 AST_MATCHER_FUNCTION(ast_matchers::internal::Matcher<Expr>,
                      hasSubstitutedType) {
   return hasType(qualType(anyOf(substTemplateTypeParmType(),
                                 hasDescendant(substTemplateTypeParmType()))));
 }
 
 } // namespace
 
Options.store(Opts, "StringLikeClasses",
                 utils::options::serializeStringList(StringLikeClasses));
 }
 
 void FasterStringFindCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   const auto SingleChar =
-      expr(ignoringParenCasts(stringLiteral(lengthIsOne()).bind("literal")));
+      expr(ignoringParenCasts(stringLiteral(hasSize(1)).bind("literal")));
 
   const auto StringFindFunctions =
       anyOf(hasName("find"), hasName("rfind"), hasName("find_first_of"),
             hasName("find_first_not_of"), hasName("find_last_of"),
             hasName("find_last_not_of"));
 
   llvm::Optional<ast_matchers::internal::Matcher<NamedDecl>> IsStringClass;
 

clang-tidy/readability/ImplicitBoolCastCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 namespace {
 
-AST_MATCHER_P(CastExpr, hasCastKind, CastKind, Kind) {
-  return Node.getCastKind() == Kind;
-}
-
 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();

clang-tidy/readability/RedundantStringInitCheck.cpp

 //===- RedundantStringInitCheck.cpp - clang-tidy ----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RedundantStringInitCheck.h"
+#include "../utils/Matchers.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
+using namespace clang::tidy::matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
-namespace {
-
-AST_MATCHER(StringLiteral, lengthIsZero) { return Node.getLength() == 0; }
-
-AST_MATCHER_P(Expr, ignoringImplicit,
-              ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
-  return InnerMatcher.matches(*Node.IgnoreImplicit(), Finder, Builder);
-}
-
-} // namespace
-
 void RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   // Match string constructor.
   const auto StringConstructorExpr = expr(anyOf(
       cxxConstructExpr(argumentCountIs(1),
                        hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
       // If present, the second argument is the alloc object which must not
       // be present explicitly.
       cxxConstructExpr(argumentCountIs(2),
                        hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
                        hasArgument(1, cxxDefaultArgExpr()))));
 
   // Match a string constructor expression with an empty string literal.
   const auto EmptyStringCtorExpr =
       cxxConstructExpr(StringConstructorExpr,
           hasArgument(0, ignoringParenImpCasts(
-                             stringLiteral(lengthIsZero()))));
+                             stringLiteral(hasSize(0)))));
 
   const auto EmptyStringCtorExprWithTemporaries =
       expr(ignoringImplicit(
           cxxConstructExpr(StringConstructorExpr,
               hasArgument(0, ignoringImplicit(EmptyStringCtorExpr)))));
 
   // Match a variable declaration with an empty string literal as initializer.
   // Examples:

clang-tidy/utils/Matchers.h

 
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "TypeTraits.h"
 
 namespace clang {
 namespace tidy {
 namespace matchers {
 
+AST_MATCHER_P(Expr, ignoringImplicit,
+              ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
+  return InnerMatcher.matches(*Node.IgnoreImplicit(), Finder, Builder);
+}
+
 AST_MATCHER(BinaryOperator, isRelationalOperator) {
   return Node.isRelationalOp();
 }
 
 AST_MATCHER(BinaryOperator, isEqualityOperator) {
   return Node.isEqualityOp();
 }