Adapt clang-tidy checks to changing semantics of hasDeclaration.

[bkramer]

clang-tidy/google/StringReferenceMemberCheck.cpp

31 ↗

(On Diff #109128)

I think this should be namedDecl too.

[klimek]

Address review comment.

[klimek]

ptal

[bkramer]

looks good

clang-tools-extra/trunk/clang-tidy/google/StringReferenceMemberCheck.cpp

 void StringReferenceMemberCheck::registerMatchers(
     ast_matchers::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 const references to std::string or ::string.
-  auto String = anyOf(recordDecl(hasName("::std::basic_string")),
-                      recordDecl(hasName("::string")));
+  auto String = anyOf(namedDecl(hasName("::std::string")),
+                      namedDecl(hasName("::string")));
   auto ConstString = qualType(isConstQualified(), hasDeclaration(String));
 
   // Ignore members in template instantiations.
   Finder->addMatcher(
       fieldDecl(hasType(references(ConstString)), unless(isInstantiated()))
           .bind("member"),
       this);
 }

clang-tools-extra/trunk/clang-tidy/misc/DanglingHandleCheck.cpp

ast_matchers::internal::BindableMatcher<Stmt> makeContainerMatcher(
   //                  the bug. A little more complicated than what we have now.
   return callExpr(
       hasAnyArgument(
           ignoringParenImpCasts(handleFromTemporaryValue(IsAHandle))),
       anyOf(
           // For sequences: assign, push_back, resize.
           cxxMemberCallExpr(
               callee(functionDecl(hasAnyName("assign", "push_back", "resize"))),
-              on(expr(hasType(recordDecl(isASequence()))))),
+              on(expr(hasType(hasUnqualifiedDesugaredType(
+                  recordType(hasDeclaration(recordDecl(isASequence())))))))),
           // For sequences and sets: insert.
-          cxxMemberCallExpr(
-              callee(functionDecl(hasName("insert"))),
-              on(expr(hasType(recordDecl(anyOf(isASequence(), isASet())))))),
+          cxxMemberCallExpr(callee(functionDecl(hasName("insert"))),
+                            on(expr(hasType(hasUnqualifiedDesugaredType(
+                                recordType(hasDeclaration(recordDecl(
+                                    anyOf(isASequence(), isASet()))))))))),
           // For maps: operator[].
           cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(isAMap()))),
                               hasOverloadedOperatorName("[]"))));
 }
 
 } // anonymous namespace
 
 DanglingHandleCheck::DanglingHandleCheck(StringRef Name,
Options.store(Opts, "HandleClasses",
                 utils::options::serializeStringList(HandleClasses));
 }
 
 void DanglingHandleCheck::registerMatchersForVariables(MatchFinder *Finder) {
   const auto ConvertedHandle = handleFromTemporaryValue(IsAHandle);
 
   // Find 'Handle foo(ReturnsAValue());'
   Finder->addMatcher(
-      varDecl(hasType(cxxRecordDecl(IsAHandle)),
+      varDecl(hasType(hasUnqualifiedDesugaredType(
+                  recordType(hasDeclaration(cxxRecordDecl(IsAHandle))))),
               hasInitializer(
                   exprWithCleanups(has(ignoringParenImpCasts(ConvertedHandle)))
                       .bind("bad_stmt"))),
       this);
 
   // Find 'Handle foo = ReturnsAValue();'
   Finder->addMatcher(
       varDecl(
-          hasType(cxxRecordDecl(IsAHandle)), unless(parmVarDecl()),
+          hasType(hasUnqualifiedDesugaredType(
+              recordType(hasDeclaration(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("="),
void DanglingHandleCheck::registerMatchersForReturn(MatchFinder *Finder) {
   Finder->addMatcher(
       returnStmt(
           // The AST contains two constructor calls:
           //   1. Value to Handle conversion.
           //   2. Handle copy construction.
           // We have to match both.
           has(ignoringImplicit(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))))))))))),
+              handleFrom(IsAHandle,
+                         declRefExpr(to(varDecl(
+                                   hasType(hasUnqualifiedDesugaredType(
+                                       recordType(hasDeclaration(recordDecl(
+                                           unless(IsAHandle)))))))))))))),
           // Temporary fix for false positives inside lambdas.
           unless(hasAncestor(lambdaExpr())))
           .bind("bad_stmt"),
       this);
 
   // Return a temporary.
   Finder->addMatcher(
       returnStmt(

clang-tools-extra/trunk/clang-tidy/misc/InaccurateEraseCheck.cpp

const auto EndCall =
           hasArgument(
               1,
               anyOf(cxxConstructExpr(has(ignoringImplicit(
                         cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end"))))
                             .bind("end")))),
                     anything())))
           .bind("alg");
 
-  const auto DeclInStd = decl(isInStdNamespace());
+  const auto DeclInStd = type(hasUnqualifiedDesugaredType(
+      tagType(hasDeclaration(decl(isInStdNamespace())))));
   Finder->addMatcher(
       cxxMemberCallExpr(
           on(anyOf(hasType(DeclInStd), hasType(pointsTo(DeclInStd)))),
           callee(cxxMethodDecl(hasName("erase"))), argumentCountIs(1),
           hasArgument(0, has(ignoringImplicit(
                              anyOf(EndCall, has(ignoringImplicit(EndCall)))))),
           unless(isInTemplateInstantiation()))
           .bind("erase"),

clang-tools-extra/trunk/clang-tidy/misc/UseAfterMoveCheck.cpp

 
 void UseAfterMoveFinder::getReinits(
     const CFGBlock *Block, const ValueDecl *MovedVariable,
     llvm::SmallPtrSetImpl<const Stmt *> *Stmts,
     llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs) {
   auto DeclRefMatcher =
       declRefExpr(hasDeclaration(equalsNode(MovedVariable))).bind("declref");
 
-  auto StandardContainerTypeMatcher = hasType(cxxRecordDecl(
-      hasAnyName("::std::basic_string", "::std::vector", "::std::deque",
-                 "::std::forward_list", "::std::list", "::std::set",
-                 "::std::map", "::std::multiset", "::std::multimap",
-                 "::std::unordered_set", "::std::unordered_map",
-                 "::std::unordered_multiset", "::std::unordered_multimap")));
-
-  auto StandardSmartPointerTypeMatcher = hasType(cxxRecordDecl(
-      hasAnyName("::std::unique_ptr", "::std::shared_ptr", "::std::weak_ptr")));
+  auto StandardContainerTypeMatcher = hasType(hasUnqualifiedDesugaredType(
+      recordType(hasDeclaration(cxxRecordDecl(hasAnyName(
+          "::std::basic_string", "::std::vector", "::std::deque",
+          "::std::forward_list", "::std::list", "::std::set", "::std::map",
+          "::std::multiset", "::std::multimap", "::std::unordered_set",
+          "::std::unordered_map", "::std::unordered_multiset",
+          "::std::unordered_multimap"))))));
+
+  auto StandardSmartPointerTypeMatcher = hasType(hasUnqualifiedDesugaredType(
+      recordType(hasDeclaration(cxxRecordDecl(hasAnyName(
+          "::std::unique_ptr", "::std::shared_ptr", "::std::weak_ptr"))))));
 
   // Matches different types of reinitialization.
   auto ReinitMatcher =
       stmt(anyOf(
                // Assignment. In addition to the overloaded assignment operator,
                // test for built-in assignment as well, since template functions
                // may be instantiated to use std::move() on built-in types.
                binaryOperator(hasOperatorName("="), hasLHS(DeclRefMatcher)),

clang-tools-extra/trunk/clang-tidy/modernize/LoopConvertCheck.cpp

auto OverloadedNEQMatcher = ignoringImplicit(
       cxxOperatorCallExpr(hasOverloadedOperatorName("!="), argumentCountIs(2),
                           hasArgument(0, IteratorComparisonMatcher),
                           hasArgument(1, IteratorBoundMatcher)));
 
   // This matcher tests that a declaration is a CXXRecordDecl that has an
   // overloaded operator*(). If the operator*() returns by value instead of by
   // reference then the return type is tagged with DerefByValueResultName.
   internal::Matcher<VarDecl> TestDerefReturnsByValue =
-      hasType(cxxRecordDecl(hasMethod(allOf(
+      hasType(hasUnqualifiedDesugaredType(
+          recordType(hasDeclaration(cxxRecordDecl(hasMethod(allOf(
               hasOverloadedOperatorName("*"),
               anyOf(
                   // Tag the return type if it's by value.
                   returns(qualType(unless(hasCanonicalType(referenceType())))
                               .bind(DerefByValueResultName)),
                   returns(
                       // Skip loops where the iterator's operator* returns an
                       // rvalue reference. This is just weird.
                       qualType(unless(hasCanonicalType(rValueReferenceType())))
-                      .bind(DerefByRefResultName)))))));
+                          .bind(DerefByRefResultName))))))))));
 
   return forStmt(
              unless(isInTemplateInstantiation()),
              hasLoopInit(anyOf(declStmt(declCountIs(2),
                                         containsDeclaration(0, InitDeclMatcher),
                                         containsDeclaration(1, EndDeclMatcher)),
                                declStmt(hasSingleDecl(InitDeclMatcher)))),
              hasCondition(
StatementMatcher makePseudoArrayLoopMatcher() {
   // return type of begin/end is an iterator that dereferences to the same as
   // what operator[] or at() returns. Such a test isn't likely to fail except
   // for pathological cases.
   //
   // FIXME: Also, a record doesn't necessarily need begin() and end(). Free
   // functions called begin() and end() taking the container as an argument
   // are also allowed.
   TypeMatcher RecordWithBeginEnd = qualType(anyOf(
-      qualType(isConstQualified(),
-               hasDeclaration(cxxRecordDecl(
-                   hasMethod(cxxMethodDecl(hasName("begin"), isConst())),
-                   hasMethod(cxxMethodDecl(hasName("end"),
-                                           isConst())))) // hasDeclaration
-               ),                                        // qualType
-      qualType(
-          unless(isConstQualified()),
-          hasDeclaration(cxxRecordDecl(hasMethod(hasName("begin")),
-                                       hasMethod(hasName("end"))))) // qualType
+      qualType(
+          isConstQualified(),
+          hasUnqualifiedDesugaredType(recordType(hasDeclaration(cxxRecordDecl(
+                                      isConst()))))   // hasDeclaration
+                                                 ))), // qualType
+      qualType(unless(isConstQualified()),
+               hasUnqualifiedDesugaredType(recordType(hasDeclaration(
+                   cxxRecordDecl(hasMethod(hasName("begin")),
+                                 hasMethod(hasName("end"))))))) // qualType
       ));
 
   StatementMatcher SizeCallMatcher = cxxMemberCallExpr(
       argumentCountIs(0),
       callee(cxxMethodDecl(anyOf(hasName("size"), hasName("length")))),
       on(anyOf(hasType(pointsTo(RecordWithBeginEnd)),
                hasType(RecordWithBeginEnd))));
 

clang-tools-extra/trunk/clang-tidy/modernize/MakeSharedCheck.cpp

 namespace tidy {
 namespace modernize {
 
 MakeSharedCheck::MakeSharedCheck(StringRef Name, ClangTidyContext *Context)
     : MakeSmartPtrCheck(Name, Context, "std::make_shared") {}
 
 MakeSharedCheck::SmartPtrTypeMatcher
 MakeSharedCheck::getSmartPointerTypeMatcher() const {
-  return qualType(hasDeclaration(classTemplateSpecializationDecl(
+  return qualType(hasUnqualifiedDesugaredType(
+      recordType(hasDeclaration(classTemplateSpecializationDecl(
           hasName("::std::shared_ptr"), templateArgumentCountIs(1),
-      hasTemplateArgument(
-          0, templateArgument(refersToType(qualType().bind(PointerType)))))));
+          hasTemplateArgument(0, templateArgument(refersToType(
+                                     qualType().bind(PointerType)))))))));
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/MakeUniqueCheck.cpp

 namespace modernize {
 
 MakeUniqueCheck::MakeUniqueCheck(StringRef Name,
                                  clang::tidy::ClangTidyContext *Context)
     : MakeSmartPtrCheck(Name, Context, "std::make_unique") {}
 
 MakeUniqueCheck::SmartPtrTypeMatcher
 MakeUniqueCheck::getSmartPointerTypeMatcher() const {
-  return qualType(hasDeclaration(classTemplateSpecializationDecl(
+  return qualType(hasUnqualifiedDesugaredType(
+      recordType(hasDeclaration(classTemplateSpecializationDecl(
           hasName("::std::unique_ptr"), templateArgumentCountIs(2),
           hasTemplateArgument(
               0, templateArgument(refersToType(qualType().bind(PointerType)))),
           hasTemplateArgument(
-          1,
-          templateArgument(refersToType(
+              1, templateArgument(refersToType(
                      qualType(hasDeclaration(classTemplateSpecializationDecl(
-                  hasName("::std::default_delete"), templateArgumentCountIs(1),
+                         hasName("::std::default_delete"),
+                         templateArgumentCountIs(1),
                          hasTemplateArgument(
-                      0, templateArgument(refersToType(
-                             qualType(equalsBoundNode(PointerType))))))))))))));
+                             0, templateArgument(refersToType(qualType(
+                                    equalsBoundNode(PointerType))))))))))))))));
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/performance/FasterStringFindCheck.cpp

const auto StringFindFunctions =
       hasAnyName("find", "rfind", "find_first_of", "find_first_not_of",
                  "find_last_of", "find_last_not_of");
 
   Finder->addMatcher(
       cxxMemberCallExpr(
           callee(functionDecl(StringFindFunctions).bind("func")),
           anyOf(argumentCountIs(1), argumentCountIs(2)),
           hasArgument(0, SingleChar),
-          on(expr(hasType(recordDecl(hasAnyName(SmallVector<StringRef, 4>(
-                      StringLikeClasses.begin(), StringLikeClasses.end())))),
-                  unless(hasSubstitutedType())))),
+          on(expr(
+              hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(
+                  recordDecl(hasAnyName(SmallVector<StringRef, 4>(
+                      StringLikeClasses.begin(), StringLikeClasses.end()))))))),
       this);
 }
 
 void FasterStringFindCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("literal");
   const auto *FindFunc = Result.Nodes.getNodeAs<FunctionDecl>("func");
 
   auto Replacement = MakeCharacterLiteral(Literal);

clang-tools-extra/trunk/clang-tidy/performance/InefficientStringConcatenationCheck.cpp

: ClangTidyCheck(Name, Context),
       StrictMode(Options.getLocalOrGlobal("StrictMode", 0)) {}
 
 void InefficientStringConcatenationCheck::registerMatchers(
     MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   const auto BasicStringType =
-      hasType(cxxRecordDecl(hasName("::std::basic_string")));
+      hasType(qualType(hasUnqualifiedDesugaredType(recordType(
+          hasDeclaration(cxxRecordDecl(hasName("::std::basic_string")))))));
 
   const auto BasicStringPlusOperator = cxxOperatorCallExpr(
       hasOverloadedOperatorName("+"),
       hasAnyArgument(ignoringImpCasts(declRefExpr(BasicStringType))));
 
   const auto PlusOperator =
       cxxOperatorCallExpr(
           hasOverloadedOperatorName("+"),

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

ContainerSizeEmptyCheck::ContainerSizeEmptyCheck(StringRef Name,
     : 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 ValidContainer = cxxRecordDecl(isSameOrDerivedFrom(
+  const auto ValidContainer = qualType(hasUnqualifiedDesugaredType(
+      recordType(hasDeclaration(cxxRecordDecl(isSameOrDerivedFrom(
           namedDecl(
               has(cxxMethodDecl(
-                  isConst(), parameterCountIs(0), isPublic(), hasName("size"),
+                      isConst(), parameterCountIs(0), isPublic(),
+                      hasName("size"),
                       returns(qualType(isInteger(), unless(booleanType()))))
                       .bind("size")),
               has(cxxMethodDecl(isConst(), parameterCountIs(0), isPublic(),
                                 hasName("empty"), returns(booleanType()))
                       .bind("empty")))
-          .bind("container")));
+              .bind("container")))))));
 
   const auto WrongUse = anyOf(
       hasParent(binaryOperator(
                     matchers::isComparisonOperator(),
                     hasEitherOperand(ignoringImpCasts(anyOf(
                         integerLiteral(equals(1)), integerLiteral(equals(0))))))
                     .bind("SizeBinaryOp")),
       hasParent(implicitCastExpr(

clang-tools-extra/trunk/clang-tidy/readability/RedundantStringCStrCheck.cpp

 void RedundantStringCStrCheck::registerMatchers(
     ast_matchers::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;
 
   // Match expressions of type 'string' or 'string*'.
-  const auto StringDecl = cxxRecordDecl(hasName("::std::basic_string"));
+  const auto StringDecl = type(hasUnqualifiedDesugaredType(recordType(
+      hasDeclaration(cxxRecordDecl(hasName("::std::basic_string"))))));
   const auto StringExpr =
       expr(anyOf(hasType(StringDecl), hasType(qualType(pointsTo(StringDecl)))));
 
   // Match string constructor.
   const auto StringConstructorExpr = expr(anyOf(
       cxxConstructExpr(argumentCountIs(1),
                        hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
       cxxConstructExpr(

clang-tools-extra/trunk/clang-tidy/readability/RedundantStringInitCheck.cpp

const auto EmptyStringCtorExprWithTemporaries =
                        hasArgument(0, ignoringImplicit(EmptyStringCtorExpr)));
 
   // Match a variable declaration with an empty string literal as initializer.
   // Examples:
   //     string foo = "";
   //     string bar("");
   Finder->addMatcher(
       namedDecl(
-          varDecl(hasType(cxxRecordDecl(hasName("basic_string"))),
+          varDecl(hasType(hasUnqualifiedDesugaredType(recordType(
+                      hasDeclaration(cxxRecordDecl(hasName("basic_string")))))),
                   hasInitializer(expr(ignoringImplicit(anyOf(
                                           EmptyStringCtorExpr,
                                           EmptyStringCtorExprWithTemporaries)))
                                      .bind("expr"))),
           unless(parmVarDecl()))
           .bind("decl"),
       this);
 }

clang-tools-extra/trunk/include-fixer/find-all-symbols/FindAllSymbols.cpp

MatchFinder->addMatcher(
               loc(typedefType(hasDeclaration(Typedefs.bind("use"))))),
       this);
   // Uses of class templates:
   // The typeLoc names the templateSpecializationType. Its declaration is the
   // ClassTemplateDecl, which contains the CXXRecordDecl we want.
   MatchFinder->addMatcher(
       typeLoc(isExpansionInMainFile(),
               loc(templateSpecializationType(hasDeclaration(
-                  classTemplateDecl(has(CXXRecords.bind("use"))))))),
+                  classTemplateSpecializationDecl(hasSpecializedTemplate(
+                      classTemplateDecl(has(CXXRecords.bind("use"))))))))),
       this);
 }
 
 void FindAllSymbols::run(const MatchFinder::MatchResult &Result) {
   // Ignore Results in failing TUs.
   if (Result.Context->getDiagnostics().hasErrorOccurred()) {
     return;
   }