Add handling for DeducedType to HasDeclarationMatcher

[fgross]

Summary

HasDeclarationMatcher did not handle DeducedType, it always returned false for deduced types.

So with code like this:

struct X{};
auto x = X{};

This did no longer match:

varDecl(hasType(recordDecl(hasName("X"))))

Because HasDeclarationMatcher didn't resolve the DeducedType of x.

This came up because some checks in clang-tidy didn't match as expected anymore.

[klimek]

Thanks! LG after comment change.

Also, should we add some tests to clang-tidy? :)

include/clang/ASTMatchers/ASTMatchersInternal.h

745

I think the behavior doesn't need a comment, but the reason :)

// DeducedType dos not have declarations of its own, so
// match the deduced type instead.

[fgross]

Changed comment, added some clang-tidy test cases.

include/clang/ASTMatchers/ASTMatchersInternal.h

bool matchesSpecialized(const QualType &Node, ASTMatchFinder *Finder,
 
     return matchesSpecialized(*Node, Finder, Builder);
   }
 
   /// \brief Finds the best declaration for a type and returns whether the inner
   /// matcher matches on it.
   bool matchesSpecialized(const Type &Node, ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const {
+
+    // DeducedType does not have declarations of its own, so
+    // match the deduced type instead.
+    const Type *EffectiveType = &Node;
+    if (const auto *S = dyn_cast<DeducedType>(&Node)) {
+      EffectiveType = S->getDeducedType().getTypePtrOrNull();
+      if (!EffectiveType)
+        return false;
+    }
+
     // First, for any types that have a declaration, extract the declaration and
     // match on it.
-    if (const auto *S = dyn_cast<TagType>(&Node)) {
+    if (const auto *S = dyn_cast<TagType>(EffectiveType)) {
       return matchesDecl(S->getDecl(), Finder, Builder);
     }
-    if (const auto *S = dyn_cast<InjectedClassNameType>(&Node)) {
+    if (const auto *S = dyn_cast<InjectedClassNameType>(EffectiveType)) {
       return matchesDecl(S->getDecl(), Finder, Builder);
     }
-    if (const auto *S = dyn_cast<TemplateTypeParmType>(&Node)) {
+    if (const auto *S = dyn_cast<TemplateTypeParmType>(EffectiveType)) {
       return matchesDecl(S->getDecl(), Finder, Builder);
     }
-    if (const auto *S = dyn_cast<TypedefType>(&Node)) {
+    if (const auto *S = dyn_cast<TypedefType>(EffectiveType)) {
       return matchesDecl(S->getDecl(), Finder, Builder);
     }
-    if (const auto *S = dyn_cast<UnresolvedUsingType>(&Node)) {
+    if (const auto *S = dyn_cast<UnresolvedUsingType>(EffectiveType)) {
       return matchesDecl(S->getDecl(), Finder, Builder);
     }
-    if (const auto *S = dyn_cast<ObjCObjectType>(&Node)) {
+    if (const auto *S = dyn_cast<ObjCObjectType>(EffectiveType)) {
       return matchesDecl(S->getInterface(), Finder, Builder);
     }
 
     // A SubstTemplateTypeParmType exists solely to mark a type substitution
     // on the instantiated template. As users usually want to match the
     // template parameter on the uninitialized template, we can always desugar
     // one level without loss of expressivness.
     // For example, given:
     //   template<typename T> struct X { T t; } class A {}; X<A> a;
     // The following matcher will match, which otherwise would not:
     //   fieldDecl(hasType(pointerType())).
-    if (const auto *S = dyn_cast<SubstTemplateTypeParmType>(&Node)) {
+    if (const auto *S = dyn_cast<SubstTemplateTypeParmType>(EffectiveType)) {
       return matchesSpecialized(S->getReplacementType(), Finder, Builder);
     }
 
     // For template specialization types, we want to match the template
     // declaration, as long as the type is still dependent, and otherwise the
     // declaration of the instantiated tag type.
-    if (const auto *S = dyn_cast<TemplateSpecializationType>(&Node)) {
+    if (const auto *S = dyn_cast<TemplateSpecializationType>(EffectiveType)) {
       if (!S->isTypeAlias() && S->isSugared()) {
         // If the template is non-dependent, we want to match the instantiated
         // tag type.
         // For example, given:
         //   template<typename T> struct X {}; X<int> a;
         // The following matcher will match, which otherwise would not:
         //   templateSpecializationType(hasDeclaration(cxxRecordDecl())).
         return matchesSpecialized(*S->desugar(), Finder, Builder);
       }
       // If the template is dependent or an alias, match the template
       // declaration.
       return matchesDecl(S->getTemplateName().getAsTemplateDecl(), Finder,
                          Builder);
     }
 
     // FIXME: We desugar elaborated types. This makes the assumption that users
     // do never want to match on whether a type is elaborated - there are
     // arguments for both sides; for now, continue desugaring.
-    if (const auto *S = dyn_cast<ElaboratedType>(&Node)) {
+    if (const auto *S = dyn_cast<ElaboratedType>(EffectiveType)) {
       return matchesSpecialized(S->desugar(), Finder, Builder);
     }
     return false;
   }
 
   /// \brief Extracts the Decl the DeclRefExpr references and returns whether
   /// the inner matcher matches on it.
   bool matchesSpecialized(const DeclRefExpr &Node, ASTMatchFinder *Finder,

test/clang-tidy/misc-use-after-move.cpp

void standardContainerClearIsReinit() {
     container.clear();
     container.empty();
   }
   {
     std::vector<int> container;
     std::move(container);
     container.clear();
     container.empty();
+
+    auto container2 = container;
+    std::move(container2);
+    container2.clear();
+    container2.empty();
   }
   {
     std::deque<int> container;
     std::move(container);
     container.clear();
     container.empty();
   }
   {

test/clang-tidy/performance-inefficient-string-concatenation.cpp

 }
 
 void f(std::string) {}
 std::string g(std::string) {}
 
 int main() {
   std::string mystr1, mystr2;
   std::wstring mywstr1, mywstr2;
+  auto myautostr1 = mystr1;
+  auto myautostr2 = mystr2;
 
   for (int i = 0; i < 10; ++i) {
     f(mystr1 + mystr2 + mystr1);
     // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: string concatenation results in allocation of unnecessary temporary strings; consider using 'operator+=' or 'string::append()' instead
     mystr1 = mystr1 + mystr2;
     // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
     mystr1 = mystr2 + mystr2 + mystr2;
     // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: string concatenation
     mystr1 = mystr2 + mystr1;
     // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
     mywstr1 = mywstr2 + mywstr1;
     // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
     mywstr1 = mywstr2 + mywstr2 + mywstr2;
     // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: string concatenation
+    myautostr1 = myautostr1 + myautostr2;
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
 
     mywstr1 = mywstr2 + mywstr2;
     mystr1 = mystr2 + mystr2;
     mystr1 += mystr2;
     f(mystr2 + mystr1);
     mystr1 = g(mystr1);
   }
   return 0;
 }

test/clang-tidy/readability-redundant-smartptr-get.cpp

void Positive() {
   // CHECK-FIXES: (**up).Do();
 
   int_ptr ip;
   int i = *ip.get();
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant get() call
   // CHECK-MESSAGES: int i = *ip.get();
   // CHECK-FIXES: int i = *ip;
 
+  auto ip2 = ip;
+  i = *ip2.get();
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: redundant get() call
+  // CHECK-MESSAGES: i = *ip2.get();
+  // CHECK-FIXES: i = *ip2;
+
   std::unique_ptr<int> uu;
   std::shared_ptr<double> *ss;
   bool bb = uu.get() == nullptr;
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: redundant get() call
   // CHECK-MESSAGES: uu.get() == nullptr;
   // CHECK-FIXES: bool bb = uu == nullptr;
 
   bb = nullptr != ss->get();

test/clang-tidy/readability-uniqueptr-delete-release.cpp

 std::unique_ptr<int>& ReturnsAUnique();
 
 void Positives() {
   std::unique_ptr<int> P;
   delete P.release();
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer '= nullptr' to 'delete x.release()' to reset unique_ptr<> objects [readability-uniqueptr-delete-release]
   // CHECK-FIXES: {{^}}  P = nullptr;
 
+  auto P2 = P;
+  delete P2.release();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer '= nullptr' to 'delete x.release()' to reset unique_ptr<> objects [readability-uniqueptr-delete-release]
+  // CHECK-FIXES: {{^}}  P2 = nullptr;
+
   std::unique_ptr<int> Array[20];
   delete Array[4].release();
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer '= nullptr' to 'delete
   // CHECK-FIXES: {{^}}  Array[4] = nullptr;
 
   delete ReturnsAUnique().release();
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: prefer '= nullptr' to 'delete
   // CHECK-FIXES: {{^}}  ReturnsAUnique() = nullptr;

unittests/ASTMatchers/ASTMatchersNodeTest.cpp

TEST(TypeMatching, MatchesAtomicTypes) {
   }
 }
 
 TEST(TypeMatching, MatchesAutoTypes) {
   EXPECT_TRUE(matches("auto i = 2;", autoType()));
   EXPECT_TRUE(matches("int v[] = { 2, 3 }; void f() { for (int i : v) {} }",
                       autoType()));
 
+  EXPECT_TRUE(matches("auto i = 2;", varDecl(hasType(isInteger()))));
+  EXPECT_TRUE(matches("struct X{}; auto x = X{};",
+                      varDecl(hasType(recordDecl(hasName("X"))))));
+
   // FIXME: Matching against the type-as-written can't work here, because the
   //        type as written was not deduced.
   //EXPECT_TRUE(matches("auto a = 1;",
   //                    autoType(hasDeducedType(isInteger()))));
   //EXPECT_TRUE(notMatches("auto b = 2.0;",
   //                       autoType(hasDeducedType(isInteger()))));
 }