[clang-move] Find template class forward declarations more precisely.

[ioeric]

Could you add the following test case for dumping all decls?

template <typename T>
class Foo {
 public:
  Foo() {}
};
typedef Foo<int> Foo_i;

[ioeric]

Lgtm. Looks like the test case should already be covered.

clang-move/ClangMove.cpp

void ClangMoveTool::addRemovedDecl(const NamedDecl *Decl) {
   RemovedDecls.push_back(Decl);
 }
 
 void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
   auto InOldHeader =
       isExpansionInFile(makeAbsolutePath(Context->Spec.OldHeader));
   auto InOldCC = isExpansionInFile(makeAbsolutePath(Context->Spec.OldCC));
   auto InOldFiles = anyOf(InOldHeader, InOldCC);
-  auto ForwardDecls =
-      cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition())));
+  auto classTemplateForwardDecls =
+      classTemplateDecl(unless(has(cxxRecordDecl(isDefinition()))));
+  auto ForwardClassDecls = namedDecl(
+      anyOf(cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition()))),
+            classTemplateForwardDecls));
   auto TopLevelDecl =
       hasDeclContext(anyOf(namespaceDecl(), translationUnitDecl()));
 
   //============================================================================
   // Matchers for old header
   //============================================================================
   // Match all top-level named declarations (e.g. function, variable, enum) in
   // old header, exclude forward class declarations and namespace declarations.
   //
   // We consider declarations inside a class belongs to the class. So these
   // declarations will be ignored.
   auto AllDeclsInHeader = namedDecl(
-      unless(ForwardDecls), unless(namespaceDecl()),
-      unless(usingDirectiveDecl()),                 // using namespace decl.
-      unless(classTemplateDecl(has(ForwardDecls))), // template forward decl.
+      unless(ForwardClassDecls), unless(namespaceDecl()),
+      unless(usingDirectiveDecl()), // using namespace decl.
       InOldHeader,
       hasParent(decl(anyOf(namespaceDecl(), translationUnitDecl()))),
       hasDeclContext(decl(anyOf(namespaceDecl(), translationUnitDecl()))));
   Finder->addMatcher(AllDeclsInHeader.bind("decls_in_header"), this);
 
   // Don't register other matchers when dumping all declarations in header.
   if (Context->DumpDeclarations)
     return;
 
   // Match forward declarations in old header.
-  Finder->addMatcher(namedDecl(ForwardDecls, InOldHeader).bind("fwd_decl"),
+  Finder->addMatcher(namedDecl(ForwardClassDecls, InOldHeader).bind("fwd_decl"),
                      this);
 
   //============================================================================
   // Matchers for old cc
   //============================================================================
   auto IsOldCCTopLevelDecl = allOf(
       hasParent(decl(anyOf(namespaceDecl(), translationUnitDecl()))), InOldCC);
   // Matching using decls/type alias decls which are in named/anonymous/global

unittests/clang-move/ClangMoveTests.cpp

const char TestHeader[] = "template <typename T>\n"
                             "class B {};\n"
                             "\n"
                             "namespace a {\n"
                             "class Move1 {};\n"
                             "void f1() {}\n"
                             "void f2();\n"
                             "} // namespace a\n"
                             "\n"
+                            "class ForwardClass;\n"
                             "namespace a {\n"
                             "namespace b {\n"
                             "class Move1 { public : void f(); };\n"
                             "void f() {}\n"
                             "enum E1 { Green };\n"
                             "enum class E2 { Red };\n"
                             "typedef int Int2;\n"
+                            "typedef A<double> A_d;"
                             "using Int = int;\n"
                             "extern int kGlobalInt;\n"
                             "extern const char* const kGlobalStr;\n"
                             "} // namespace b\n"
                             "} // namespace a\n";
   const char TestCode[] = "#include \"foo.h\"\n";
   move::MoveDefinitionSpec Spec;
   Spec.Names.push_back("B");
   Spec.OldHeader = "foo.h";
   Spec.OldCC = "foo.cc";
   Spec.NewHeader = "new_foo.h";
   Spec.NewCC = "new_foo.cc";
   DeclarationReporter Reporter;
   std::set<DeclarationReporter::DeclarationPair> ExpectedDeclarations = {
-      {"A", "Class"},         {"B", "Class"},        {"a::Move1", "Class"},
-      {"a::f1", "Function"},  {"a::f2", "Function"}, {"a::b::Move1", "Class"},
-      {"a::b::f", "Function"}, {"a::b::E1", "Enum"}, {"a::b::E2", "Enum"},
-      {"a::b::Int2", "TypeAlias"}, {"a::b::Int", "TypeAlias"},
-      {"a::b::kGlobalInt", "Variable"}, {"a::b::kGlobalStr", "Variable"}};
+      {"A", "Class"},
+      {"B", "Class"},
+      {"a::Move1", "Class"},
+      {"a::f1", "Function"},
+      {"a::f2", "Function"},
+      {"a::b::Move1", "Class"},
+      {"a::b::f", "Function"},
+      {"a::b::E1", "Enum"},
+      {"a::b::E2", "Enum"},
+      {"a::b::Int2", "TypeAlias"},
+      {"a::b::A_d", "TypeAlias"},
+      {"a::b::Int", "TypeAlias"},
+      {"a::b::kGlobalInt", "Variable"},
+      {"a::b::kGlobalStr", "Variable"}};
   runClangMoveOnCode(Spec, TestHeader, TestCode, &Reporter);
   std::set<DeclarationReporter::DeclarationPair> Results;
   for (const auto& DelPair : Reporter.getDeclarationList())
     Results.insert(DelPair);
   EXPECT_EQ(ExpectedDeclarations, Results);
 }
 
 } // namespace
 } // namespce move
 } // namespace clang