[find-all-symbols] Add enum type support.

[hokein]

Summary

Also change enums defined in SymbolInfo to scoped enums to avoid
conflicts.

[bkramer]

lg

clang-tools-extra/trunk/include-fixer/InMemoryXrefsDB.cpp

for (const auto &Entry : LookupTable) {
     for (const auto &Header : Entry.second) {
       std::vector<SymbolInfo::Context> Contexts;
       for (auto IdentiferContext = Names.rbegin() + 1;
            IdentiferContext != Names.rend(); ++IdentiferContext) {
         Contexts.emplace_back(SymbolInfo::ContextType::Namespace,
                               *IdentiferContext);
       }
 
-      SymbolInfo Symbol(Names.back(), SymbolInfo::Class, Header, Contexts, 1);
+      SymbolInfo Symbol(Names.back(), SymbolInfo::SymbolKind::Class, Header,
+                        Contexts, 1);
       this->LookupTable[Symbol.getName()].push_back(Symbol);
     }
   }
 }
 
 std::vector<SymbolInfo> InMemoryXrefsDB::search(llvm::StringRef Identifier) {
   auto I = LookupTable.find(Identifier);
   if (I != LookupTable.end())
     return I->second;
   return {};
 }
 
 } // namespace include_fixer
 } // namespace clang

clang-tools-extra/trunk/include-fixer/find-all-symbols/FindAllSymbols.cpp

 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/FileSystem.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace find_all_symbols {
 namespace {
+
+AST_MATCHER(EnumConstantDecl, isInScopedEnum) {
+  if (const auto *ED = dyn_cast<EnumDecl>(Node.getDeclContext()))
+    return ED->isScoped();
+  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;
 
     assert(llvm::isa<NamedDecl>(Context) &&
            "Expect Context to be a NamedDecl");
     if (const auto *NSD = dyn_cast<NamespaceDecl>(Context)) {
-      Contexts.emplace_back(SymbolInfo::Namespace, NSD->isAnonymousNamespace()
-                                                       ? ""
+      Contexts.emplace_back(SymbolInfo::ContextType::Namespace,
+                            NSD->isAnonymousNamespace() ? ""
                                                         : NSD->getName().str());
+    } else if (const auto *ED = dyn_cast<EnumDecl>(Context)) {
+      Contexts.emplace_back(SymbolInfo::ContextType::EnumDecl,
+                            ED->getName().str());
     } else {
       const auto *RD = cast<RecordDecl>(Context);
-      Contexts.emplace_back(SymbolInfo::Record, RD->getName().str());
+      Contexts.emplace_back(SymbolInfo::ContextType::Record,
+                            RD->getName().str());
     }
   }
   return Contexts;
 }
 
 llvm::Optional<SymbolInfo> CreateSymbolInfo(const NamedDecl *ND,
                                             const SourceManager &SM) {
   SymbolInfo::SymbolKind Type;
   if (llvm::isa<VarDecl>(ND)) {
-    Type = SymbolInfo::Variable;
+    Type = SymbolInfo::SymbolKind::Variable;
   } else if (llvm::isa<FunctionDecl>(ND)) {
-    Type = SymbolInfo::Function;
+    Type = SymbolInfo::SymbolKind::Function;
   } else if (llvm::isa<TypedefNameDecl>(ND)) {
-    Type = SymbolInfo::TypedefName;
+    Type = SymbolInfo::SymbolKind::TypedefName;
+  } else if (llvm::isa<EnumConstantDecl>(ND)) {
+    Type = SymbolInfo::SymbolKind::EnumConstantDecl;
+  } else if (llvm::isa<EnumDecl>(ND)) {
+    Type = SymbolInfo::SymbolKind::EnumDecl;
   } else {
-    assert(llvm::isa<RecordDecl>(ND) && "Matched decl must be one of VarDecl, "
-                                        "FunctionDecl, TypedefNameDecl and "
-                                        "RecordDecl!");
+    assert(llvm::isa<RecordDecl>(ND) &&
+           "Matched decl must be one of VarDecl, "
+           "FunctionDecl, TypedefNameDecl, EnumConstantDecl, "
+           "EnumDecl and RecordDecl!");
     // C-style record decl can have empty name, e.g "struct { ... } var;".
     if (ND->getName().empty())
       return llvm::None;
-    Type = SymbolInfo::Class;
+    Type = SymbolInfo::SymbolKind::Class;
   }
 
   SourceLocation Loc = SM.getExpansionLoc(ND->getLocation());
   if (!Loc.isValid()) {
     llvm::errs() << "Declaration " << ND->getNameAsString() << "("
                  << ND->getDeclKindName()
                  << ") has invalid declaration location.";
     return llvm::None;
void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
   // both C-style header and C++ header (except for those in classes).
   // "cc_matchers" are not included since template-related matchers are not
   // applicable on `TypedefNameDecl`.
   MatchFinder->addMatcher(
       typedefNameDecl(CommonFilter, anyOf(HasNSOrTUCtxMatcher,
                                           hasDeclContext(linkageSpecDecl())))
           .bind("decl"),
       this);
+
+  // Matchers for enum declarations.
+  MatchFinder->addMatcher(
+      enumDecl(CommonFilter, anyOf(HasNSOrTUCtxMatcher, ExternCMatcher))
+          .bind("decl"),
+      this);
+
+  // Matchers for enum constant declarations.
+  // We only match the enum constants in non-scoped enum declarations which are
+  // inside toplevel translation unit or a namespace.
+  MatchFinder->addMatcher(
+      enumConstantDecl(
+          CommonFilter,
+          unless(isInScopedEnum()),
+          anyOf(hasDeclContext(enumDecl(HasNSOrTUCtxMatcher)), ExternCMatcher))
+          .bind("decl"),
+      this);
 }
 
 void FindAllSymbols::run(const MatchFinder::MatchResult &Result) {
   // Ignore Results in failing TUs.
   if (Result.Context->getDiagnostics().hasErrorOccurred()) {
     return;
   }
 

clang-tools-extra/trunk/include-fixer/find-all-symbols/SymbolInfo.h

 
 namespace clang {
 namespace find_all_symbols {
 
 /// \brief Contains all information for a Symbol.
 class SymbolInfo {
 public:
   /// \brief The SymbolInfo Type.
-  enum SymbolKind {
+  enum class SymbolKind {
     Function,
     Class,
     Variable,
     TypedefName,
+    EnumDecl,
+    EnumConstantDecl,
     Unknown,
   };
 
   /// \brief The Context Type.
-  enum ContextType {
+  enum class ContextType {
     Namespace, // Symbols declared in a namespace.
     Record,    // Symbols declared in a class.
+    EnumDecl,  // Enum constants declared in a enum declaration.
   };
 
   /// \brief A pair of <ContextType, ContextName>.
   typedef std::pair<ContextType, std::string> Context;
 
   // The default constructor is required by YAML traits in
   // LLVM_YAML_IS_DOCUMENT_LIST_VECTOR.
-  SymbolInfo() : Type(Unknown), LineNumber(-1) {};
+  SymbolInfo() : Type(SymbolKind::Unknown), LineNumber(-1) {};
 
   SymbolInfo(llvm::StringRef Name, SymbolKind Type, llvm::StringRef FilePath,
              const std::vector<Context> &Contexts, int LineNumber);
 
   /// \brief Get symbol name.
   llvm::StringRef getName() const;
 
   /// \brief Get symbol type.

clang-tools-extra/trunk/include-fixer/find-all-symbols/SymbolInfo.cpp

 };
 
 template <> struct ScalarEnumerationTraits<SymbolKind> {
   static void enumeration(IO &io, SymbolKind &value) {
     io.enumCase(value, "Variable", SymbolKind::Variable);
     io.enumCase(value, "Function", SymbolKind::Function);
     io.enumCase(value, "Class", SymbolKind::Class);
     io.enumCase(value, "TypedefName", SymbolKind::TypedefName);
+    io.enumCase(value, "EnumDecl", SymbolKind::EnumDecl);
+    io.enumCase(value, "EnumConstantDecl", SymbolKind::EnumConstantDecl);
+    io.enumCase(value, "Unknown", SymbolKind::Unknown);
   }
 };
 
 template <> struct MappingTraits<SymbolInfo::Context> {
   static void mapping(IO &io, SymbolInfo::Context &Context) {
     io.mapRequired("ContextType", Context.first);
     io.mapRequired("ContextName", Context.second);
   }

clang-tools-extra/trunk/unittests/include-fixer/find-all-symbols/FindAllSymbolsTests.cpp

TEST_F(FindAllSymbolsTest, VariableSymbols) {
   static const char Code[] = R"(
       extern int xargc;
       namespace na {
       static bool SSSS = false;
       namespace nb { const long long *XXXX; }
       })";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol =
-      CreateSymbolInfo("xargc", SymbolInfo::Variable, HeaderName, 2, {});
+  SymbolInfo Symbol = CreateSymbolInfo(
+      "xargc", SymbolInfo::SymbolKind::Variable, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("SSSS", SymbolInfo::Variable, HeaderName, 4,
-                            {{SymbolInfo::Namespace, "na"}});
+  Symbol =
+      CreateSymbolInfo("SSSS", SymbolInfo::SymbolKind::Variable, HeaderName, 4,
+                       {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo(
-      "XXXX", SymbolInfo::Variable, HeaderName, 5,
-      {{SymbolInfo::Namespace, "nb"}, {SymbolInfo::Namespace, "na"}});
+  Symbol =
+      CreateSymbolInfo("XXXX", SymbolInfo::SymbolKind::Variable, HeaderName, 5,
+                       {{SymbolInfo::ContextType::Namespace, "nb"},
+                        {SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, ExternCSymbols) {
   static const char Code[] = R"(
       extern "C" {
       int C_Func() { return 0; }
       struct C_struct {
         int Member;
       };
       })";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol =
-      CreateSymbolInfo("C_Func", SymbolInfo::Function, HeaderName, 3, {});
+  SymbolInfo Symbol = CreateSymbolInfo(
+      "C_Func", SymbolInfo::SymbolKind::Function, HeaderName, 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("C_struct", SymbolInfo::Class, HeaderName, 4, {});
+  Symbol = CreateSymbolInfo("C_struct", SymbolInfo::SymbolKind::Class,
+                            HeaderName, 4, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CXXRecordSymbols) {
   static const char Code[] = R"(
       struct Glob {};
       struct A; // Not a defintion, ignored.
       class NOP; // Not a defintion, ignored
       namespace na {
       struct A {
         struct AAAA {};
         int x;
         int y;
         void f() {}
       };
       };  //
       )";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol =
-      CreateSymbolInfo("Glob", SymbolInfo::Class, HeaderName, 2, {});
+  SymbolInfo Symbol = CreateSymbolInfo("Glob", SymbolInfo::SymbolKind::Class,
+                                       HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("A", SymbolInfo::Class, HeaderName, 6,
-                            {{SymbolInfo::Namespace, "na"}});
+  Symbol = CreateSymbolInfo("A", SymbolInfo::SymbolKind::Class, HeaderName, 6,
+                            {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
+
+  Symbol = CreateSymbolInfo("AAA", SymbolInfo::SymbolKind::Class, HeaderName, 7,
+                            {{SymbolInfo::ContextType::Record, "A"},
+                             {SymbolInfo::ContextType::Namespace, "na"}});
+  EXPECT_FALSE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CXXRecordSymbolsTemplate) {
   static const char Code[] = R"(
       template <typename T>
       class T_TEMP {
         template <typename _Tp1>
         struct rebind { typedef T_TEMP<_Tp1> other; };
       };
       // Ignore specialization.
       template class T_TEMP<char>;
 
       template <typename T>
       class Observer {
       };
       // Ignore specialization.
       template <> class Observer<int> {};
       )";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol =
-      CreateSymbolInfo("T_TEMP", SymbolInfo::Class, HeaderName, 3, {});
+  SymbolInfo Symbol = CreateSymbolInfo("T_TEMP", SymbolInfo::SymbolKind::Class,
+                                       HeaderName, 3, {});
   EXPECT_TRUE(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 {
       namespace nb {
       template<typename T>
       void fun(T t) {};
       } // namespace nb
       } // namespace na";
       )";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol = CreateSymbolInfo("gg", SymbolInfo::Function, HeaderName,
-                                       3, {{SymbolInfo::Namespace, "na"}});
+  SymbolInfo Symbol =
+      CreateSymbolInfo("gg", SymbolInfo::SymbolKind::Function, HeaderName, 3,
+                       {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("f", SymbolInfo::Function, HeaderName, 4,
-                            {{SymbolInfo::Namespace, "na"}});
+  Symbol = CreateSymbolInfo("f", SymbolInfo::SymbolKind::Function, HeaderName,
+                            4, {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("SSSFFF", SymbolInfo::Function, HeaderName, 5,
-                            {{SymbolInfo::Namespace, "na"}});
+  Symbol =
+      CreateSymbolInfo("SSSFFF", SymbolInfo::SymbolKind::Function, HeaderName,
+                       5, {{SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo(
-      "fun", SymbolInfo::Function, HeaderName, 10,
-      {{SymbolInfo::Namespace, "nb"}, {SymbolInfo::Namespace, "na"}});
+  Symbol = CreateSymbolInfo("fun", SymbolInfo::SymbolKind::Function, HeaderName,
+                            10, {{SymbolInfo::ContextType::Namespace, "nb"},
+                                 {SymbolInfo::ContextType::Namespace, "na"}});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, NamespaceTest) {
   static const char Code[] = R"(
       int X1;
       namespace { int X2; }
       namespace { namespace { int X3; } }
       namespace { namespace nb { int X4;} }
       )";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol =
-      CreateSymbolInfo("X1", SymbolInfo::Variable, HeaderName, 2, {});
+  SymbolInfo Symbol = CreateSymbolInfo("X1", SymbolInfo::SymbolKind::Variable,
+                                       HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("X2", SymbolInfo::Variable, HeaderName, 3,
-                            {{SymbolInfo::Namespace, ""}});
+  Symbol = CreateSymbolInfo("X2", SymbolInfo::SymbolKind::Variable, HeaderName,
+                            3, {{SymbolInfo::ContextType::Namespace, ""}});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo(
-      "X3", SymbolInfo::Variable, HeaderName, 4,
-      {{SymbolInfo::Namespace, ""}, {SymbolInfo::Namespace, ""}});
+  Symbol = CreateSymbolInfo("X3", SymbolInfo::SymbolKind::Variable, HeaderName,
+                            4, {{SymbolInfo::ContextType::Namespace, ""},
+                                {SymbolInfo::ContextType::Namespace, ""}});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo(
-      "X4", SymbolInfo::Variable, HeaderName, 5,
-      {{SymbolInfo::Namespace, "nb"}, {SymbolInfo::Namespace, ""}});
+  Symbol = CreateSymbolInfo("X4", SymbolInfo::SymbolKind::Variable, HeaderName,
+                            5, {{SymbolInfo::ContextType::Namespace, "nb"},
+                                {SymbolInfo::ContextType::Namespace, ""}});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, DecayedTypeTest) {
   static const char Code[] = "void DecayedFunc(int x[], int y[10]) {}";
   runFindAllSymbols(Code);
-  SymbolInfo Symbol =
-      CreateSymbolInfo("DecayedFunc", SymbolInfo::Function, HeaderName, 1, {});
+  SymbolInfo Symbol = CreateSymbolInfo(
+      "DecayedFunc", SymbolInfo::SymbolKind::Function, HeaderName, 1, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CTypedefTest) {
   static const char Code[] = R"(
       typedef unsigned size_t_;
       typedef struct { int x; } X;
       using XX = X;
       )";
   runFindAllSymbols(Code);
 
-  SymbolInfo Symbol =
-      CreateSymbolInfo("size_t_", SymbolInfo::TypedefName, HeaderName, 2, {});
+  SymbolInfo Symbol = CreateSymbolInfo(
+      "size_t_", SymbolInfo::SymbolKind::TypedefName, HeaderName, 2, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("X", SymbolInfo::TypedefName, HeaderName, 3, {});
+  Symbol = CreateSymbolInfo("X", SymbolInfo::SymbolKind::TypedefName,
+                            HeaderName, 3, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 
-  Symbol = CreateSymbolInfo("XX", SymbolInfo::TypedefName, HeaderName, 4, {});
+  Symbol = CreateSymbolInfo("XX", SymbolInfo::SymbolKind::TypedefName,
+                            HeaderName, 4, {});
   EXPECT_TRUE(hasSymbol(Symbol));
 }
 
+TEST_F(FindAllSymbolsTest, EnumTest) {
+  static const char Code[] = R"(
+      enum Glob_E { G1, G2 };
+      enum class Altitude { high='h', low='l'};
+      enum { A1, A2 };
+      class A {
+      public:
+        enum A_ENUM { X1, X2 };
+      };
+      )";
+  runFindAllSymbols(Code);
+
+  SymbolInfo Symbol = CreateSymbolInfo(
+      "Glob_E", SymbolInfo::SymbolKind::EnumDecl, HeaderName, 2, {});
+  EXPECT_TRUE(hasSymbol(Symbol));
+
+  Symbol = CreateSymbolInfo("G1", SymbolInfo::SymbolKind::EnumConstantDecl,
+                            HeaderName, 2,
+                            {{SymbolInfo::ContextType::EnumDecl, "Glob_E"}});
+  EXPECT_TRUE(hasSymbol(Symbol));
+
+  Symbol = CreateSymbolInfo("G2", SymbolInfo::SymbolKind::EnumConstantDecl,
+                            HeaderName, 2,
+                            {{SymbolInfo::ContextType::EnumDecl, "Glob_E"}});
+  EXPECT_TRUE(hasSymbol(Symbol));
+
+  Symbol = CreateSymbolInfo("Altitude", SymbolInfo::SymbolKind::EnumDecl,
+                            HeaderName, 3, {});
+  EXPECT_TRUE(hasSymbol(Symbol));
+  Symbol = CreateSymbolInfo("high", SymbolInfo::SymbolKind::EnumConstantDecl,
+                            HeaderName, 3,
+                            {{SymbolInfo::ContextType::EnumDecl, "Altitude"}});
+  EXPECT_FALSE(hasSymbol(Symbol));
+
+  Symbol = CreateSymbolInfo("A1", SymbolInfo::SymbolKind::EnumConstantDecl,
+                            HeaderName, 4,
+                            {{SymbolInfo::ContextType::EnumDecl, ""}});
+  EXPECT_TRUE(hasSymbol(Symbol));
+  Symbol = CreateSymbolInfo("A2", SymbolInfo::SymbolKind::EnumConstantDecl,
+                            HeaderName, 4,
+                            {{SymbolInfo::ContextType::EnumDecl, ""}});
+  EXPECT_TRUE(hasSymbol(Symbol));
+
+  Symbol =
+      CreateSymbolInfo("A_ENUM", SymbolInfo::SymbolKind::EnumDecl, HeaderName,
+                       7, {{SymbolInfo::ContextType::Record, "A"}});
+  EXPECT_FALSE(hasSymbol(Symbol));
+
+  Symbol = CreateSymbolInfo("X1", SymbolInfo::SymbolKind::EnumDecl, HeaderName,
+                            7, {{SymbolInfo::ContextType::EnumDecl, "A_ENUM"},
+                                {SymbolInfo::ContextType::Record, "A"}});
+  EXPECT_FALSE(hasSymbol(Symbol));
+}
+
 } // namespace find_all_symbols
 } // namespace clang