[clang-move] Dump enum and type alias declarations.

[ioeric]

Lg

clang-move/ClangMove.cpp

if (Context->DumpDeclarations) {
     for (const auto *Decl : UnremovedDeclsInOldHeader) {
       auto Kind = Decl->getKind();
       const std::string QualifiedName = Decl->getQualifiedNameAsString();
       if (Kind == Decl::Kind::Function || Kind == Decl::Kind::FunctionTemplate)
         Reporter->reportDeclaration(QualifiedName, "Function");
       else if (Kind == Decl::Kind::ClassTemplate ||
                Kind == Decl::Kind::CXXRecord)
         Reporter->reportDeclaration(QualifiedName, "Class");
+      else if (Kind == Decl::Kind::Enum)
+        Reporter->reportDeclaration(QualifiedName, "Enum");
+      else if (Kind == Decl::Kind::Typedef ||
+               Kind == Decl::Kind::TypeAlias ||
+               Kind == Decl::Kind::TypeAliasTemplate)
+        Reporter->reportDeclaration(QualifiedName, "TypeAlias");
     }
     return;
   }
 
   if (RemovedDecls.empty())
     return;
   // Ignore symbols that are not supported (e.g. typedef and enum) when
   // checking if there is unremoved symbol in old header. This makes sure that

unittests/clang-move/ClangMoveTests.cpp

const char TestHeader[] = "template <typename T>\n"
                             "void f1() {}\n"
                             "void f2();\n"
                             "} // namespace a\n"
                             "\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"
+                            "using Int = int;\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::vector<DeclarationReporter::DeclarationPair> ExpectedDeclarations = {
+  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::f", "Function"}, {"a::b::E1", "Enum"}, {"a::b::E2", "Enum"},
+      {"a::b::Int2", "TypeAlias"}, {"a::b::Int", "TypeAlias"} };
   runClangMoveOnCode(Spec, TestHeader, TestCode, &Reporter);
-  const auto& Results = Reporter.getDeclarationList();
-  auto ActualDeclIter = Results.begin();
-  auto ExpectedDeclIter = ExpectedDeclarations.begin();
-  while (ActualDeclIter != Results.end() &&
-         ExpectedDeclIter != ExpectedDeclarations.end()) {
-    EXPECT_EQ(*ActualDeclIter, *ExpectedDeclIter);
-    ++ActualDeclIter;
-    ++ExpectedDeclIter;
-  }
-  ASSERT_TRUE(ActualDeclIter == Results.end());
-  ASSERT_TRUE(ExpectedDeclIter == ExpectedDeclarations.end());
+  std::set<DeclarationReporter::DeclarationPair> Results;
+  for (const auto& DelPair : Reporter.getDeclarationList())
+    Results.insert(DelPair);
+  EXPECT_EQ(ExpectedDeclarations, Results);
 }
 
 } // namespace
 } // namespce move
 } // namespace clang