[include-cleaner] Attribute references to explicit specializations

[kadircet]

Summary

Fixes https://github.com/llvm/llvm-project/issues/61652

[hokein]

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

81

I think we should be careful about the case where ND == nullptr, isa will trigger an assertion, use isa_and_present.

82

We seem to miss a testcase for TypeAliasTemplateDecl, add one?

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

119

nit: The indentation looks weird, the template... should not align with the above testWalk text, would be better to add 4 space indentation.

[kadircet]

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

82

we already have one, pointed it there

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

206

this is where we have the template alias type test already

[kadircet]

• use isa_and_present
• indentation for tests

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

 //===--- WalkAST.cpp - Find declaration references in the AST -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AnalysisInternal.h"
+#include "clang-include-cleaner/Types.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #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/SourceLocation.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 *getMemberProvider(QualType Base) {
     // is supported (the base type is a Foo*).
     //
     // There are some exceptions that this heuristic could fail (dependent base,
     // dependent typealias), but we believe these are rare.
     if (const auto *TST = dyn_cast<TemplateSpecializationType>(Base))
       return resolveTemplateName(TST->getTemplateName());
     return Base->getAsRecordDecl();
   }
+  // Templated as TemplateSpecializationType and
+  // DeducedTemplateSpecializationType doesn't share a common base.
+  template <typename T>
+  // Picks the most specific specialization for a
+  // (Deduced)TemplateSpecializationType, while prioritizing using-decls.
+  NamedDecl *getMostRelevantTemplatePattern(const T *TST) {
+    // This is the underlying decl used by TemplateSpecializationType, can be
+    // null when type is dependent.
+    auto *RD = TST->getAsTagDecl();
+    auto *ND = resolveTemplateName(TST->getTemplateName());
+    // 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.
+    if (llvm::isa<UsingShadowDecl, TypeAliasTemplateDecl>(ND) || !RD)
+      return ND;
+    return RD;
+  }
 
 public:
   ASTWalker(DeclCallback Callback) : Callback(Callback) {}
 
   bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
     if (!WalkUpFromCXXOperatorCallExpr(S))
       return false;
 
public:
   }
 
   bool VisitTypedefTypeLoc(TypedefTypeLoc TTL) {
     report(TTL.getNameLoc(), TTL.getTypedefNameDecl());
     return true;
   }
 
   bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
-    // FIXME: Handle explicit specializations.
     report(TL.getTemplateNameLoc(),
-           resolveTemplateName(TL.getTypePtr()->getTemplateName()));
+           getMostRelevantTemplatePattern(TL.getTypePtr()));
     return true;
   }
 
   bool VisitDeducedTemplateSpecializationTypeLoc(
       DeducedTemplateSpecializationTypeLoc TL) {
-    // FIXME: Handle specializations.
     report(TL.getTemplateNameLoc(),
-           resolveTemplateName(TL.getTypePtr()->getTemplateName()));
+           getMostRelevantTemplatePattern(TL.getTypePtr()));
     return true;
   }
 
   bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &TL) {
     auto &Arg = TL.getArgument();
     // Template-template parameters require special attention, as there's no
     // TemplateNameLoc.
     if (Arg.getKind() == TemplateArgument::Template ||

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

 
 TEST(WalkAST, TagType) {
   testWalk("struct $explicit^S {};", "^S *y;");
   testWalk("enum $explicit^E {};", "^E *y;");
   testWalk("struct $explicit^S { static int x; };", "int y = ^S::x;");
   // One explicit call from the TypeLoc in constructor spelling, another
   // implicit reference through the constructor call.
   testWalk("struct $explicit^$implicit^S { static int x; };", "auto y = ^S();");
+  testWalk("template<typename> struct $explicit^Foo {};", "^Foo<int> x;");
+  testWalk(R"cpp(
+  template<typename> struct Foo {};
+  template<> struct $explicit^Foo<int> {};)cpp",
+           "^Foo<int> x;");
+  testWalk(R"cpp(
+  template<typename> struct Foo {};
+  template<typename T> struct $explicit^Foo<T*> { void x(); };)cpp",
+           "^Foo<int *> x;");
+  testWalk(R"cpp(
+  template<typename> struct Foo {};
+  template struct $explicit^Foo<int>;)cpp",
+           "^Foo<int> x;");
+  // FIXME: This is broken due to
+  // https://github.com/llvm/llvm-project/issues/42259.
+  testWalk(R"cpp(
+  template<typename T> struct $explicit^Foo { Foo(T); };
+  template<> struct Foo<int> { void get(); Foo(int); };)cpp",
+           "^Foo x(3);");
 }
 
 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;");
   testWalk("struct S {}; using $explicit^foo = S;", "^foo x;");
+  testWalk(R"cpp(
+  template<typename> struct Foo {};
+  template<> struct Foo<int> {};
+  namespace ns { using ::$explicit^Foo; })cpp",
+           "ns::^Foo<int> x;");
+  testWalk(R"cpp(
+  template<typename> struct Foo {};
+  namespace ns { using ::Foo; }
+  template<> struct ns::$explicit^Foo<int> {};)cpp",
+           "^Foo<int> x;");
+  // AST doesn't have enough information to figure out whether specialization
+  // happened through an exported type or not. So err towards attributing use to
+  // the using-decl, specializations on the exported type should be rare and
+  // they're not permitted on type-aliases.
+  testWalk(R"cpp(
+  template<typename> struct Foo {};
+  namespace ns { using ::$explicit^Foo; }
+  template<> struct ns::Foo<int> {};)cpp",
+           "ns::^Foo<int> x;");
 }
 
 TEST(WalkAST, Using) {
   // We should report unused overloads as ambiguous.
   testWalk(R"cpp(
     namespace ns {
       void $explicit^x(); void $ambiguous^x(int); void $ambiguous^x(char);
     })cpp",

 }
 
 TEST(WalkAST, TemplateNames) {
   testWalk("template<typename> struct $explicit^S {};", "^S<int> s;");
   // FIXME: Template decl has the wrong primary location for type-alias template
   // decls.
   testWalk(R"cpp(
       template <typename> struct S {};
       template <typename T> $explicit^using foo = S<T>;)cpp",
            "^foo<int> x;");
   testWalk(R"cpp(
       namespace ns {template <typename> struct S {}; }
       using ns::$explicit^S;)cpp",
            "^S<int> x;");
   testWalk(R"cpp(
       namespace ns {
         template <typename T> struct S { S(T);};
         template <typename T> S(T t) -> S<T>;
       }
       using ns::$explicit^S;)cpp",
       "^S x(123);");
   testWalk("template<typename> struct $explicit^S {};",
            R"cpp(
       template <template <typename> typename> struct X {};
       X<^S> x;)cpp");
   testWalk("template<typename T> struct $explicit^S { S(T); };", "^S s(42);");
-  // Should we mark the specialization instead?
-  testWalk(
-      "template<typename> struct $explicit^S {}; template <> struct S<int> {};",
-      "^S<int> s;");
 }
 
 TEST(WalkAST, MemberExprs) {
   testWalk("struct $implicit^S { void foo(); };", "void foo() { S{}.^foo(); }");
   testWalk(
       "struct S { void foo(); }; struct $implicit^X : S { using S::foo; };",
       "void foo() { X{}.^foo(); }");
   testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",