[clang-tidy] Don't emit misc-unused-using-decl warnings for header files.

[hokein]

Summary

Using decls in header files are special, usually as part of the
public API, the check should not emit warnings on these.

The check already detects unused using-decls which are in the current main
file, but if the main file happens to be a header file, we still
emit warnings, this patch suppresses that.

[Eugene.Zelenko]

clang-tools-extra/docs/clang-tidy/checks/misc/unused-using-decls.rst

26

Please use single back-ticks for option values.

Actually this is second patch with similar functionality during last month and I think this option should be shared between all checks.

[ymandel]

Thanks!

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

48

nit: no need for braces on the if statement.

clang-tools-extra/docs/clang-tidy/checks/misc/unused-using-decls.rst

26

Eugene -- are you suggesting that is a blocker on this patch, or just a good idea for clang-tidy in general?

27

[Eugene.Zelenko]

clang-tools-extra/docs/clang-tidy/checks/misc/unused-using-decls.rst

26

Sure, it'll be better to do this as separate patch, but this should be done at some point. It;s both code duplication and more complex complex setup for users.

[carlosgalvezp]

clang-tools-extra/docs/clang-tidy/checks/misc/unused-using-decls.rst

26

I'm planning to add the suggested functionality in a separate patch when I find some time. Can fix existing checks as well.

[hokein]

address comments

clang-tools-extra/docs/clang-tidy/checks/misc/unused-using-decls.rst

26

Thanks.

I changed to use , for option values in this patch (I thought ,, and ; are both fine, if , is more preferred, we should probably change defaultImplementationFileExtensions, and StringRef defaultHeaderFileExtensions functions in FileExtensionsUtils.h, they use ;, I just followed their way).

clang-tools-extra/clang-tidy/misc/UnusedUsingDeclsCheck.h

 //===--- UnusedUsingDeclsCheck.h - clang-tidy--------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_USING_DECLS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_USING_DECLS_H
 
 #include "../ClangTidyCheck.h"
+#include "../utils/FileExtensionsUtils.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include <vector>
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 /// Finds unused using declarations.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/misc/unused-using-decls.html
 class UnusedUsingDeclsCheck : public ClangTidyCheck {
 public:
-  UnusedUsingDeclsCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
+  UnusedUsingDeclsCheck(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void onEndOfTranslationUnit() override;
 
 private:
   void removeFromFoundDecls(const Decl *D);
 
   struct UsingDeclContext {
     explicit UsingDeclContext(const UsingDecl *FoundUsingDecl)
         : FoundUsingDecl(FoundUsingDecl), IsUsed(false) {}
     // A set saves all UsingShadowDecls introduced by a UsingDecl. A UsingDecl
     // can introduce multiple UsingShadowDecls in some cases (such as
     // overloaded functions).
     llvm::SmallPtrSet<const Decl *, 4> UsingTargetDecls;
     // The original UsingDecl.
     const UsingDecl *FoundUsingDecl;
     // The source range of the UsingDecl.
     CharSourceRange UsingDeclRange;
     // Whether the UsingDecl is used.
     bool IsUsed;
   };
 
   std::vector<UsingDeclContext> Contexts;
+
+  const StringRef RawStringHeaderFileExtensions;
+  utils::FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_USING_DECLS_H

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

 // 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<EnumDecl>(TargetDecl) ||
          isa<EnumConstantDecl>(TargetDecl);
 }
 
+UnusedUsingDeclsCheck::UnusedUsingDeclsCheck(StringRef Name,
+                                             ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
+          "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
+  if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
+                                  HeaderFileExtensions,
+                                  utils::defaultFileExtensionDelimiters()))
+    this->configurationDiag("Invalid header file extension: '%0'")
+        << RawStringHeaderFileExtensions;
+}
+
 void UnusedUsingDeclsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(usingDecl(isExpansionInMainFile()).bind("using"), this);
   auto DeclMatcher = hasDeclaration(namedDecl().bind("used"));
   Finder->addMatcher(loc(templateSpecializationType(DeclMatcher)), this);
   Finder->addMatcher(loc(deducedTemplateSpecializationType(
                          refsToTemplatedDecl(namedDecl().bind("used")))),
                      this);
   Finder->addMatcher(callExpr(callee(unresolvedLookupExpr().bind("used"))),
void UnusedUsingDeclsCheck::registerMatchers(MatchFinder *Finder) {
   auto ThroughShadowMatcher = throughUsingDecl(namedDecl().bind("usedShadow"));
   Finder->addMatcher(declRefExpr(ThroughShadowMatcher), this);
   Finder->addMatcher(loc(usingType(ThroughShadowMatcher)), this);
 }
 
 void UnusedUsingDeclsCheck::check(const MatchFinder::MatchResult &Result) {
   if (Result.Context->getDiagnostics().hasUncompilableErrorOccurred())
     return;
+  // We don't emit warnings on unused-using-decls from headers, so bail out if
+  // the main file is a header.
+  if (const auto *MainFile = Result.SourceManager->getFileEntryForID(
+          Result.SourceManager->getMainFileID());
+      utils::isFileExtension(MainFile->getName(), HeaderFileExtensions))
+    return;
 
   if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
     // Ignores using-declarations defined in macros.
     if (Using->getLocation().isMacroID())
       return;
 
     // Ignores using-declarations defined in class definition.
     if (isa<CXXRecordDecl>(Using->getDeclContext()))

clang-tools-extra/docs/clang-tidy/checks/misc/unused-using-decls.rst

 .. title:: clang-tidy - misc-unused-using-decls
 
 misc-unused-using-decls
 =======================
 
 Finds unused ``using`` declarations.
 
+Unused ``using``` declarations in header files will not be diagnosed since these
+using declarations are part of the header's public API. Allowed header file
+extensions can be configured via the `HeaderFileExtensions` option (see below).
+
 Example:
 
 .. code-block:: c++
 
+  // main.cpp
   namespace n { class C; }
   using n::C;  // Never actually used.
+
+Options
+-------
+
+.. option:: HeaderFileExtensions
+
+   A semicolon-separated list of filename extensions of header files (the filename
+   extensions should not include "." prefix). Default is "h,hh,hpp,hxx".
+   For extension-less header files, use an empty string or leave an
+   empty string between "," if there are other filename extensions.

clang-tools-extra/test/clang-tidy/checkers/misc/unused-using-decls.hxx

+// RUN: %check_clang_tidy %s misc-unused-using-decls %t -- --fix-notes -- -fno-delayed-template-parsing -isystem %S/Inputs
+
+// Verify that we don't generate the warnings on header files.
+namespace foo { class Foo {}; }
+
+using foo::Foo;