[clang-tidy] Warning enum unused using declarations.

[aaron.ballman]

LGTM!

[alexfh]

LG

clang-tools-extra/trunk/clang-tidy/misc/UnusedUsingDeclsCheck.cpp

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 // A function that helps to tell whether a TargetDecl in a UsingDecl will be
-// checked. Only variable, function, function template, class template and class
-// are considered.
+// checked. Only variable, function, function template, class template, class,
+// enum declaration and enum constant declaration are considered.
 static bool ShouldCheckDecl(const Decl *TargetDecl) {
   return isa<RecordDecl>(TargetDecl) || isa<ClassTemplateDecl>(TargetDecl) ||
          isa<FunctionDecl>(TargetDecl) || isa<VarDecl>(TargetDecl) ||
-         isa<FunctionTemplateDecl>(TargetDecl);
+         isa<FunctionTemplateDecl>(TargetDecl) || isa<EnumDecl>(TargetDecl) ||
+         isa<EnumConstantDecl>(TargetDecl);
 }
 
 void UnusedUsingDeclsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(usingDecl(isExpansionInMainFile()).bind("using"), this);
   auto DeclMatcher = hasDeclaration(namedDecl().bind("used"));
   Finder->addMatcher(loc(recordType(DeclMatcher)), this);
   Finder->addMatcher(loc(templateSpecializationType(DeclMatcher)), this);
   Finder->addMatcher(declRefExpr().bind("used"), this);
void UnusedUsingDeclsCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *DRE = Result.Nodes.getNodeAs<DeclRefExpr>("used")) {
     if (const auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
       if (const auto *FDT = FD->getPrimaryTemplate())
         removeFromFoundDecls(FDT);
       else
         removeFromFoundDecls(FD);
     } else if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
       removeFromFoundDecls(VD);
+    } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
+      removeFromFoundDecls(ECD);
     }
   }
   // Check the uninstantiated template function usage.
   if (const auto *ULE = Result.Nodes.getNodeAs<UnresolvedLookupExpr>("used")) {
     for (const NamedDecl* ND : ULE->decls()) {
       if (const auto *USD = dyn_cast<UsingShadowDecl>(ND))
         removeFromFoundDecls(USD->getTargetDecl()->getCanonicalDecl());
     }

clang-tools-extra/trunk/test/clang-tidy/misc-unused-using-decls.cpp

 int FuncUsedByUsingDeclInMacro() { return 1; }
 
 class ostream {
 public:
   ostream &operator<<(ostream &(*PF)(ostream &));
 };
 extern ostream cout;
 ostream &endl(ostream &os);
-}
+
+enum Color {
+  Green,
+  Red,
+  Yellow
+};
+
+}  // namespace n
 
 // ----- Using declarations -----
 // eol-comments aren't removed (yet)
 using n::A; // A
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'A' is unused
 // CHECK-FIXES: {{^}}// A
 using n::B;
 using n::C;

 void f(G g);
 }
 
 void IgnoreFunctionScope() {
 // Using-decls defined in function scope will be ignored.
 using n::H;
 }
 
+using n::Color;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'Color' is unused
+using n::Green;
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'Green' is unused
+using n::Red;
+
 // ----- Usages -----
 void f(B b);
 void g() {
   vector<C> data;
   D::i = 1;
   F<int> f;
   void (*func)() = &G::func;
   int *i = &H::i;
   UsedInstance.i;
   UsedFunc();
   UsedTemplateFunc<int>();
   cout << endl;
+  int t = Red;
 }