[clang-tidy] Fix template agrument false positives in unused-using-decls.

[hokein]

Summary

• Fix a false postive when an using class is used in an explicit template instantiation.
• Fix a false postive when an using template class is used as template argument.

[aaron.ballman]

test/clang-tidy/misc-unused-using-decls.cpp

191 ↗

(On Diff #74139)

Can you add a test using a non-type template argument, like an integer literal? I believe that still causes the diagnostic, though do we want it to?

[hokein]

Add FIXME.

test/clang-tidy/misc-unused-using-decls.cpp

191 ↗

(On Diff #74139)

Yeah, I agree that we need support non-type template arguments in the long term, but it seems out of scope of this patch (Supporting all non-type template arguments needs more stuff), I have added to FIXME.

[aaron.ballman]

test/clang-tidy/misc-unused-using-decls.cpp

191 ↗

(On Diff #74139)

Certainly; I would mostly like a test showing that we considered it and understand the current behavior. If the test has a FIXME comment with it, that's also totally fine.

[hokein]

Add a non-type template argument test.

[aaron.ballman]

LGTM, thank you!

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

void UnusedUsingDeclsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(declRefExpr().bind("used"), this);
   Finder->addMatcher(callExpr(callee(unresolvedLookupExpr().bind("used"))),
                      this);
   Finder->addMatcher(
       callExpr(hasDeclaration(functionDecl(hasAnyTemplateArgument(
           anyOf(refersToTemplate(templateName().bind("used")),
                 refersToDeclaration(functionDecl().bind("used"))))))),
       this);
+  Finder->addMatcher(loc(templateSpecializationType(
+      hasAnyTemplateArgument(templateArgument().bind("used")))), this);
 }
 
 void UnusedUsingDeclsCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
     // Ignores using-declarations defined in macros.
     if (Using->getLocation().isMacroID())
       return;
 
if (const auto *Used = Result.Nodes.getNodeAs<NamedDecl>("used")) {
     } else if (const auto *Specialization =
                    dyn_cast<ClassTemplateSpecializationDecl>(Used)) {
       Used = Specialization->getSpecializedTemplate();
     }
     removeFromFoundDecls(Used);
     return;
   }
 
+  if (const auto *Used = Result.Nodes.getNodeAs<TemplateArgument>("used")) {
+    // FIXME: Support non-type template parameters.
+    if (Used->getKind() == TemplateArgument::Template) {
+      if (const auto *TD = Used->getAsTemplate().getAsTemplateDecl())
+        removeFromFoundDecls(TD);
+    } else if (Used->getKind() == TemplateArgument::Type) {
+      if (auto *RD = Used->getAsType()->getAsCXXRecordDecl())
+        removeFromFoundDecls(RD);
+    }
+    return;
+  }
+
   if (const auto *Used = Result.Nodes.getNodeAs<TemplateName>("used")) {
     removeFromFoundDecls(Used->getAsTemplateDecl());
     return;
   }
 
   if (const auto *DRE = Result.Nodes.getNodeAs<DeclRefExpr>("used")) {
     if (const auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
       if (const auto *FDT = FD->getPrimaryTemplate())

clang-tools-extra/trunk/test/clang-tidy/misc-unused-using-decls.cpp

 class I {
  public:
   static int ii;
 };
 template <typename T> class J {};
 class G;
 class H;
 
+template <typename T> class K {};
+template <template <typename> class S>
+class L {};
+
+template <typename T> class M {};
+class N {};
+
+template <int T> class P {};
+const int Constant = 0;
+
 class Base {
  public:
   void f();
 };
 
 D UsedInstance;
 D UnusedInstance;
 

 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'Green' is unused
 using n::Color2;
 using n::Color3;
 using n::Blue;
 
 using ns::AA;
 using ns::ff;
 
+using n::K;
+
+using n::N;
+
+// FIXME: Currently non-type template arguments are not supported.
+using n::Constant;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'Constant' is unused
+
 // ----- Usages -----
 void f(B b);
 void g() {
   vector<C> data;
   D::i = 1;
   F<int> f;
   void (*func)() = &G::func;
   int *i = &H::i;
   UsedInstance.i;
   UsedFunc();
   UsedTemplateFunc<int>();
   cout << endl;
   Color2 color2;
   int t1 = Color3::Yellow;
   int t2 = Blue;
 
   MyClass a;
   int t3 = 0;
   a.func1<AA>(&t3);
   a.func2<int, ff>(t3);
+
+  n::L<K> l;
 }
+
+template<class T>
+void h(n::M<T>* t) {}
+// n::N is used the explicit template instantiation.
+template void h(n::M<N>* t);
+
+// Test on Non-type template arguments.
+template <int T>
+void i(n::P<T>* t) {}
+template void i(n::P<Constant>* t);