[include-cleaner] Report all specializations if the primary template is introduced by a using-decl.

[hokein]

Summary

This will fix unused-include false positive.

// primary.h
namespace ns {
template<class T1, class T2> class Z {}; // primary template
}

// partial.h
namespace ns {
template<class T> class Z<T, T*> {};     // partial specialization
}

// main.cpp

using ns::Z; // refs to the primary
void k() {
  Z<int, int*> z; // use the partial specialization
}

[kadircet]

thanks!

clang-tools-extra/include-cleaner/lib/WalkAST.cpp

176

nit: prefer early exit

176

s/dyn_cast/llvm::dyn_cast

179

s/SmallVector/llvm::SmallVector

202

s/dyn_cast/llvm::dyn_cast

clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

257–272

i think we can merge these into a single test with something like:

namespace ns {
  template <typename T> struct Z {};
  template <typename T> struct Z<T*> {};
  template <> struct Z<int> {};
}

using ns::Z; // uses all 3.

same applies to var template tests.

[hokein]

address review comments.

clang-tools-extra/include-cleaner/lib/WalkAST.cpp

 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/Support/Casting.h"
 
 namespace clang::include_cleaner {
 namespace {
public:
   bool VisitOverloadExpr(OverloadExpr *E) {
     // Since we can't prove which overloads are used, report all of them.
     llvm::for_each(E->decls(), [this, E](NamedDecl *D) {
       report(E->getNameLoc(), D, RefType::Ambiguous);
     });
     return true;
   }
 
+  // Report all (partial) specializations of a class/var template decl.
+  template <typename TemplateDeclType, typename ParitialDeclType>
+  void reportSpecializations(SourceLocation Loc, NamedDecl *ND) {
+    if (const auto *TD = dyn_cast<TemplateDeclType>(ND)) {
+      for (auto *Spec : TD->specializations())
+        report(Loc, Spec, RefType::Ambiguous);
+      SmallVector<ParitialDeclType *> PartialSpecializations;
+      TD->getPartialSpecializations(PartialSpecializations);
+      for (auto *PartialSpec : PartialSpecializations) {
+        report(Loc, PartialSpec, RefType::Ambiguous);
+      }
+    }
+  }
   bool VisitUsingDecl(UsingDecl *UD) {
     for (const auto *Shadow : UD->shadows()) {
       auto *TD = Shadow->getTargetDecl();
       auto IsUsed = TD->isUsed() || TD->isReferenced();
       report(UD->getLocation(), TD,
              IsUsed ? RefType::Explicit : RefType::Ambiguous);
+
+      // All (partial) template specializations are visible via a using-decl,
+      // However a using-decl only refers to the primary template (per C++ name
+      // lookup). Thus, we need to manually report all specializations.
+      reportSpecializations<ClassTemplateDecl,
+                            ClassTemplatePartialSpecializationDecl>(
+          UD->getLocation(), TD);
+      reportSpecializations<VarTemplateDecl,
+                            VarTemplatePartialSpecializationDecl>(
+          UD->getLocation(), TD);
+      if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(TD))
+        for (auto *Spec : FTD->specializations())
+          report(UD->getLocation(), Spec, RefType::Ambiguous);
     }
     return true;
   }
 
   bool VisitFunctionDecl(FunctionDecl *FD) {
     // Mark declaration from definition as it needs type-checking.
     if (FD->isThisDeclarationADefinition())
       report(FD->getLocation(), FD);

clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

template<> void foo<int>(){})cpp",
                        "auto x = []{ ^foo<int>(); };"),
               ElementsAre(Decl::FunctionTemplate));
   EXPECT_THAT(testWalk(R"cpp(
     template<typename T> void $explicit^foo() {};
     template void foo<int>();)cpp",
                        "auto x = [] { ^foo<int>(); };"),
               ElementsAre(Decl::FunctionTemplate));
 }
+TEST(WalkAST, TemplateSpecializationsFromUsingDecl) {
+  // Class templates
+  testWalk(R"cpp(
+namespace ns {
+template<class T1, class T2> class $ambiguous^Z {}; // primary template
+template<class T> class $ambiguous^Z<T, T*> {};     // partial specialization
+template<class T> class $ambiguous^Z<T, T&> {};     // partial specialization
+}
+  )cpp",
+           "using ns::^Z;");
+  testWalk(R"cpp(
+namespace ns {
+template<class T1> class $ambiguous^Z {}; // primary template
+template<> class $ambiguous^Z<int> {};    // full specialization
+template<> class $ambiguous^Z<int*> {};   // full specialization
+}
+  )cpp",
+           "using ns::^Z;");
+
+  // Var templates
+  testWalk(R"cpp(
+namespace ns {
+template<class T>
+T $ambiguous^foo; // primary
+
+template<>
+int* $ambiguous^foo<int>; // full specialization
+}
+  )cpp",
+           "using ns::^foo;");
+  testWalk(R"cpp(
+namespace ns {
+template<class T, class U>
+T $ambiguous^bar;   // primary
+
+template<class T>
+T* $ambiguous^bar<T, int>; // partial specialization
+}
+  )cpp",
+           "using ns::^bar;");
+
+  // Function templates, no partial template specializations.
+  testWalk(R"cpp(
+namespace ns {
+template<class T>
+void $ambiguous^function(T); // primary
+
+template<>
+void $ambiguous^function(int); // full specialization
+}
+  )cpp",
+           "using ns::^function;");
+}
+
 
 TEST(WalkAST, Alias) {
   testWalk(R"cpp(
     namespace ns { int x; }
     using ns::$explicit^x;
   )cpp",
            "int y = ^x;");
   testWalk("using $explicit^foo = int;", "^foo x;");