[find-all-symbols] Index partial template specializations.

[hokein]

Summary

Fix no std::function index.

Previously, we don't index all the template specialization declarations of functions and classes (Because we assume that template functions/classes are indexed by their template declarations), but this is not always true in some cases like std::function which only has a partial template specialization declaration.

[ioeric]

Why do we allow partially specialization but fully specialization now? Could you elaborate in the cl description?

[hokein]

In D27920#628586, @ioeric wrote:

Why do we allow partially specialization but fully specialization now? Could you elaborate in the cl description?

Done.

[ioeric]

I'm not quite convinced/sure if we want to match all partial specializations just for std::function. We filtered out template specialization because there could be multiple specializations for a template in different headers and it was not clear which one we would choose. And if we do index specializations, I don't see why we would want to filter out full specializations.

We might want to wait for Ben's opinion.

[bkramer]

The reason why we disallowed specializations is that there are type-trait classes that get specialized all over the place (DenseMapInfo in LLVM is one example). I think we can get away with allowing partial specializations though. Those should be much less common and we can give the user a choice between the headers that contain them.

include-fixer/find-all-symbols/FindAllSymbols.cpp

39

PascalCase for variable names.

[hokein]

Fix code style nit.

include-fixer/find-all-symbols/FindAllSymbols.cpp

 namespace {
 
 AST_MATCHER(EnumConstantDecl, isInScopedEnum) {
   if (const auto *ED = dyn_cast<EnumDecl>(Node.getDeclContext()))
     return ED->isScoped();
   return false;
 }
 
+AST_POLYMORPHIC_MATCHER(isFullySpecialized,
+                        AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, VarDecl,
+                                                        CXXRecordDecl)) {
+  if (Node.getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
+    bool IsPartialSpecialization =
+        llvm::isa<VarTemplatePartialSpecializationDecl>(Node) ||
+        llvm::isa<ClassTemplatePartialSpecializationDecl>(Node);
+    return !IsPartialSpecialization;
+  }
+  return false;
+}
+
 std::vector<SymbolInfo::Context> GetContexts(const NamedDecl *ND) {
   std::vector<SymbolInfo::Context> Contexts;
   for (const auto *Context = ND->getDeclContext(); Context;
        Context = Context->getParent()) {
     if (llvm::isa<TranslationUnitDecl>(Context) ||
         llvm::isa<LinkageSpecDecl>(Context))
       break;
 
void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
   // We need seperate rules for C record types and C++ record types since some
   // template related matchers are inapplicable on C record declarations.
   //
   // Matchers specific to C++ code.
   // All declarations should be in namespace or translation unit.
   auto CCMatcher =
       allOf(HasNSOrTUCtxMatcher, unless(IsInSpecialization),
             unless(ast_matchers::isTemplateInstantiation()),
-            unless(isInstantiated()), unless(classTemplateSpecializationDecl()),
-            unless(isExplicitTemplateSpecialization()));
+            unless(isInstantiated()), unless(isFullySpecialized()));
 
   // Matchers specific to code in extern "C" {...}.
   auto ExternCMatcher = hasDeclContext(linkageSpecDecl());
 
   // Matchers for variable declarations.
   //
   // In most cases, `ParmVarDecl` is filtered out by hasDeclContext(...)
   // matcher since the declaration context is usually `MethodDecl`. However,
void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
 
   // Matchers for C-style record declarations in extern "C" {...}.
   MatchFinder->addMatcher(
       recordDecl(CommonFilter, ExternCMatcher, isDefinition()).bind("decl"),
       this);
 
   // Matchers for C++ record declarations.
   auto CxxRecordDecl =
-      cxxRecordDecl(CommonFilter, CCMatcher, isDefinition(),
-                    unless(isExplicitTemplateSpecialization()));
+      cxxRecordDecl(CommonFilter, CCMatcher, isDefinition());
   MatchFinder->addMatcher(CxxRecordDecl.bind("decl"), this);
 
   // Matchers for function declarations.
   // We want to exclude friend declaration, but the `DeclContext` of a friend
   // function declaration is not the class in which it is declared, so we need
   // to explicitly check if the parent is a `friendDecl`.
   MatchFinder->addMatcher(functionDecl(CommonFilter,
                                        unless(hasParent(friendDecl())),

unittests/include-fixer/find-all-symbols/FindAllSymbolsTests.cpp

static const char Code[] = R"(
       )";
   runFindAllSymbols(Code);
 
   SymbolInfo Symbol =
       SymbolInfo("T_TEMP", SymbolInfo::SymbolKind::Class, HeaderName, 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
+TEST_F(FindAllSymbolsTest, DontIgnoreTemplatePartialSpecialization) {
+  static const char Code[] = R"(
+      template<class> class Class; // undefined
+      template<class R, class... ArgTypes>
+      class Class<R(ArgTypes...)> {
+      };
+
+      template<class T> void f() {};
+      template<> void f<int>() {};
+      )";
+  runFindAllSymbols(Code);
+  SymbolInfo Symbol =
+      SymbolInfo("Class", SymbolInfo::SymbolKind::Class, HeaderName, 4, {});
+  EXPECT_TRUE(hasSymbol(Symbol));
+  Symbol =
+      SymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName, 7, {});
+  EXPECT_TRUE(hasSymbol(Symbol));
+  Symbol =
+      SymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName, 8, {});
+  EXPECT_FALSE(hasSymbol(Symbol));
+}
+
 TEST_F(FindAllSymbolsTest, FunctionSymbols) {
   static const char Code[] = R"(
       namespace na {
       int gg(int);
       int f(const int &a) { int Local; static int StaticLocal; return 0; }
       static void SSSFFF() {}
       }  // namespace na
       namespace na {