[clang-tidy] [NFC] Remove unnecessary matchers

[aaron.ballman]

LGTM!

clang-tools-extra/clang-tidy/android/ComparisonInTempFailureRetryCheck.cpp

void ComparisonInTempFailureRetryCheck::registerMatchers(MatchFinder *Finder) {
   // })
   //
   // (glibc uses `long int` instead of `typeof(x)` for the type of y).
   //
   // It's unclear how to walk up the AST from inside the expansion of `x`, and
   // we need to not complain about things like TEMP_FAILURE_RETRY(foo(x == 1)),
   // so we just match the assignment of `y = (x)` and inspect `x` from there.
   Finder->addMatcher(
-      binaryOperator(
-          hasOperatorName("="),
+      binaryOperator(hasOperatorName("="),
                      hasRHS(ignoringParenCasts(
-              binaryOperator(matchers::isComparisonOperator()).bind("binop"))),
+                         binaryOperator(isComparisonOperator()).bind("binop"))),
                      isRHSATempFailureRetryArg()),
       this);
 }
 
 void ComparisonInTempFailureRetryCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto &BinOp = *Result.Nodes.getNodeAs<BinaryOperator>("binop");
   diag(BinOp.getOperatorLoc(), "top-level comparison in TEMP_FAILURE_RETRY");
 
   // FIXME: FixIts would be nice, but potentially nontrivial when nested macros
   // happen, e.g. `TEMP_FAILURE_RETRY(IS_ZERO(foo()))`
 }
 
 } // namespace android
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/bugprone/MisplacedWideningCastCheck.cpp

const auto ImplicitCast =
                        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(), hasEitherOperand(Cast)),
-      this);
+      binaryOperator(isComparisonOperator(), hasEitherOperand(Cast)), this);
 }
 
 static unsigned getMaxCalculationWidth(const ASTContext &Context,
                                        const Expr *E) {
   E = E->IgnoreParenImpCasts();
 
   if (const auto *Bop = dyn_cast<BinaryOperator>(E)) {
     unsigned LHSWidth = getMaxCalculationWidth(Context, Bop->getLHS());

clang-tools-extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp

void SuspiciousStringCompareCheck::storeOptions(
   Options.store(Opts, "WarnOnImplicitComparison", WarnOnImplicitComparison);
   Options.store(Opts, "WarnOnLogicalNotComparison", WarnOnLogicalNotComparison);
   Options.store(Opts, "StringCompareLikeFunctions", StringCompareLikeFunctions);
 }
 
 void SuspiciousStringCompareCheck::registerMatchers(MatchFinder *Finder) {
   // Match relational operators.
   const auto ComparisonUnaryOperator = unaryOperator(hasOperatorName("!"));
-  const auto ComparisonBinaryOperator =
-      binaryOperator(matchers::isComparisonOperator());
+  const auto ComparisonBinaryOperator = binaryOperator(isComparisonOperator());
   const auto ComparisonOperator =
       expr(anyOf(ComparisonUnaryOperator, ComparisonBinaryOperator));
 
   // Add the list of known string compare-like functions and add user-defined
   // functions.
   std::vector<std::string> FunctionNames = utils::options::parseStringList(
       (llvm::Twine(KnownStringCompareFunctions) + StringCompareLikeFunctions)
           .str());
void SuspiciousStringCompareCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       implicitCastExpr(unless(hasType(isInteger())),
                        hasSourceExpression(StringCompareCallExpr))
           .bind("invalid-conversion"),
       this);
 
   // Detect suspicious operator with string compare function as operand.
   Finder->addMatcher(
-      binaryOperator(
-          unless(anyOf(matchers::isComparisonOperator(), hasOperatorName("&&"),
+      binaryOperator(unless(anyOf(isComparisonOperator(), hasOperatorName("&&"),
                                   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(ignoringParenImpCasts(integerLiteral(unless(equals(0)))))),
             characterLiteral(), cxxBoolLiteral()));
 
-  Finder->addMatcher(binaryOperator(matchers::isComparisonOperator(),
+  Finder->addMatcher(binaryOperator(isComparisonOperator(),
                                     hasEitherOperand(StringCompareCallExpr),
                                     hasEitherOperand(InvalidLiteral))
                          .bind("invalid-comparison"),
                      this);
 }
 
 void SuspiciousStringCompareCheck::check(
     const MatchFinder::MatchResult &Result) {

clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

Finder->addMatcher(
       callExpr(callee(LegacyOwnerConsumers),
                hasAnyArgument(expr(unless(ignoringImpCasts(ConsideredOwner)),
                                    hasType(pointerType()))))
           .bind("legacy_consumer"),
       this);
 
   // Matching assignment to owners, with the rhs not being an owner nor creating
   // one.
-  Finder->addMatcher(binaryOperator(matchers::isAssignmentOperator(),
-                                    hasLHS(IsOwnerType),
+  Finder->addMatcher(binaryOperator(isAssignmentOperator(), hasLHS(IsOwnerType),
                                     hasRHS(unless(ConsideredOwner)))
                          .bind("owner_assignment"),
                      this);
 
   // Matching initialization of owners with non-owners, nor creating owners.
   Finder->addMatcher(
       namedDecl(varDecl(hasInitializer(unless(ConsideredOwner)), IsOwnerType)
                     .bind("owner_initialization")),
const auto HasConstructorInitializerForOwner =
               .bind("owner_member_initializer"))));
 
   // Match class member initialization that expects owners, but does not get
   // them.
   Finder->addMatcher(cxxRecordDecl(HasConstructorInitializerForOwner), this);
 
   // Matching on assignment operations where the RHS is a newly created owner,
   // but the LHS is not an owner.
-  Finder->addMatcher(binaryOperator(matchers::isAssignmentOperator(),
+  Finder->addMatcher(binaryOperator(isAssignmentOperator(),
                                     hasLHS(unless(IsOwnerType)),
                                     hasRHS(CreatesOwner))
                          .bind("bad_owner_creation_assignment"),
                      this);
 
   // Matching on initialization operations where the initial value is a newly
   // created owner, but the LHS is not an owner.
   Finder->addMatcher(

clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.cpp

void RedundantExpressionCheck::registerMatchers(MatchFinder *Finder) {
   const auto BannedIntegerLiteral =
       integerLiteral(expandedByMacro(KnownBannedMacroNames));
 
   // Binary with equivalent operands, like (X != 2 && X != 2).
   Finder->addMatcher(
       binaryOperator(anyOf(hasOperatorName("-"), hasOperatorName("/"),
                            hasOperatorName("%"), hasOperatorName("|"),
                            hasOperatorName("&"), hasOperatorName("^"),
-                           matchers::isComparisonOperator(),
-                           hasOperatorName("&&"), hasOperatorName("||"),
-                           hasOperatorName("=")),
+                           isComparisonOperator(), hasOperatorName("&&"),
+                           hasOperatorName("||"), hasOperatorName("=")),
                      operandsAreEquivalent(),
                      // Filter noisy false positives.
                      unless(isInTemplateInstantiation()),
                      unless(binaryOperatorIsInMacro()),
                      unless(hasType(realFloatingPointType())),
                      unless(hasEitherOperand(hasType(realFloatingPointType()))),
                      unless(hasLHS(AnyLiteralExpr)),
                      unless(hasDescendant(BannedIntegerLiteral)))

clang-tools-extra/clang-tidy/readability/ContainerSizeEmptyCheck.cpp

const auto ValidContainer = qualType(hasUnqualifiedDesugaredType(
                       .bind("size")),
               has(cxxMethodDecl(isConst(), parameterCountIs(0), isPublic(),
                                 hasName("empty"), returns(booleanType()))
                       .bind("empty")))
               .bind("container")))))));
 
   const auto WrongUse = anyOf(
       hasParent(binaryOperator(
-                    matchers::isComparisonOperator(),
+                    isComparisonOperator(),
                     hasEitherOperand(ignoringImpCasts(anyOf(
                         integerLiteral(equals(1)), integerLiteral(equals(0))))))
                     .bind("SizeBinaryOp")),
       hasParent(implicitCastExpr(
           hasImplicitDestinationType(booleanType()),
           anyOf(
               hasParent(unaryOperator(hasOperatorName("!")).bind("NegOnSize")),
               anything()))),

clang-tools-extra/clang-tidy/utils/Matchers.h

 
 #include "TypeTraits.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 namespace clang {
 namespace tidy {
 namespace matchers {
 
-AST_MATCHER(BinaryOperator, isAssignmentOperator) {
-  return Node.isAssignmentOp();
-}
-
 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 =
       utils::type_traits::isExpensiveToCopy(Node, Finder->getASTContext());
   return IsExpensive && *IsExpensive;
 }
 
 AST_MATCHER(RecordDecl, isTriviallyDefaultConstructible) {
   return utils::type_traits::recordIsTriviallyDefaultConstructible(