[include-cleaner] Handle incomplete template specializations

[kadircet]

Summary

Instantiation pattern is null for incomplete template types and using
specializaiton decl results in not seeing re-declarations.

[sammccall]

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

85–86

update comment - dependent or not resolved to a pattern yet?

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

163

There's no incomplete template here (did you mean template <typename struct Foo; or template <typename T> struct Foo<T*>;?)

If it's enough that the template is never instantiated then maybe it's still clearer not to provide a definition (and tweak the comment slightly?)

[kadircet]

• Update comments & test

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

163

If it's enough that the template is never instantiated then maybe it's still clearer not to provide a definition (and tweak the comment slightly?)

right, i meant the instantiation being "incomplete", not the template-decl itself. dropping the definition and updating the comment

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

 #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/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 {
 using DeclCallback =
     llvm::function_ref<void(SourceLocation, NamedDecl &, RefType)>;
class ASTWalker : public RecursiveASTVisitor<ASTWalker> {
   NamedDecl *getMostRelevantTemplatePattern(const T *TST) {
     // In case of exported template names always prefer the using-decl. This
     // implies we'll point at the using-decl even when there's an explicit
     // specializaiton using the exported name, but that's rare.
     auto *ND = resolveTemplateName(TST->getTemplateName());
     if (llvm::isa_and_present<UsingShadowDecl, TypeAliasTemplateDecl>(ND))
       return ND;
     // This is the underlying decl used by TemplateSpecializationType, can be
-    // null when type is dependent if so fallback to primary template.
+    // null when type is dependent or not resolved to a pattern yet.
+    // If so, fallback to primary template.
     CXXRecordDecl *TD = TST->getAsCXXRecordDecl();
-    if (!TD)
+    if (!TD || TD->getTemplateSpecializationKind() == TSK_Undeclared)
       return ND;
     // We ignore explicit instantiations. This might imply marking the wrong
     // declaration as used in specific cases, but seems like the right trade-off
     // in general (e.g. we don't want to include a custom library that has an
     // explicit specialization of a common type).
     if (auto *Pat = TD->getTemplateInstantiationPattern())
       return Pat;
     // For explicit specializations, use the specialized decl directly.

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

EXPECT_THAT(testWalk("template<typename> struct $explicit^Foo{};",
                        "template<> struct ^Foo<int> {};"),
               ElementsAre(Decl::CXXRecord));
   EXPECT_THAT(testWalk("template<typename> struct $explicit^Foo{};",
                        "template<typename T> struct ^Foo<T*> {};"),
               ElementsAre(Decl::CXXRecord));
 
   // Implicit instantiations references most relevant template.
   EXPECT_THAT(
+      testWalk("template<typename> struct $explicit^Foo;", "^Foo<int> x();"),
+      ElementsAre(Decl::Kind::ClassTemplate));
+  EXPECT_THAT(
       testWalk("template<typename> struct $explicit^Foo {};", "^Foo<int> x;"),
       ElementsAre(Decl::CXXRecord));
   EXPECT_THAT(testWalk(R"cpp(
     template<typename> struct Foo {};
     template<> struct $explicit^Foo<int> {};)cpp",
                        "^Foo<int> x;"),
               ElementsAre(Decl::ClassTemplateSpecialization));
   EXPECT_THAT(testWalk(R"cpp(
     template<typename> struct Foo {};
-    template<typename T> struct $explicit^Foo<T*> { void x(); };)cpp",
+    template<typename T> struct $explicit^Foo<T*> {};)cpp",
                        "^Foo<int *> x;"),
               ElementsAre(Decl::ClassTemplatePartialSpecialization));
+  // Incomplete instantiations don't have a specific specialization associated.
+  EXPECT_THAT(testWalk(R"cpp(
+    template<typename> struct $explicit^Foo;
+    template<typename T> struct Foo<T*>;)cpp",
+                       "^Foo<int *> x();"),
+              ElementsAre(Decl::Kind::ClassTemplate));
   EXPECT_THAT(testWalk(R"cpp(
     template<typename> struct $explicit^Foo {};
     template struct Foo<int>;)cpp",
                        "^Foo<int> x;"),
               ElementsAre(Decl::CXXRecord));
   // FIXME: This is broken due to
   // https://github.com/llvm/llvm-project/issues/42259.
   EXPECT_THAT(testWalk(R"cpp(