[clang-tidy] Add skip-headers; use skipLocation and setTraversalScope

[chh]

Summary

[clang-tidy] Add skip-headers; use skipLocation and setTraversalScope

• This depends on https://reviews.llvm.org/D104071.
• This new feature has impacts similar to --header-filter and --system-headers.
  • Clang-tidy by default checks header files, reports the number of warnings found in header files but not those warning messages.
  • With --header-filter, clang-tidy shows warnings in selected header files, but not system header files.
  • With --system-headers, clang-tidy shows also warnings in system header files.
  • With --skip-headers, clang-tidy does not check header files, and does not know or count warnings in header files. However, if --header-filter or --system-headers are used, those header files will be checked and warnings be counted and displayed.
• For users who do not need to know the number of not-shown warnings in header files, this feature saves maybe 60% to 80% of clang-tidy run-time, by skipping checks of header files. When building Android system with clang-tidy, repeated checks on commonly included header files in multiple compilation units took significant part of build time, which could be saved by this new feature.
• Note that this is not the same as PCH, which usually saves parsing time, but not semantic checks or code generation time.
• This part 1 implementation only affects the MatchFinder-based checks, not the PPCallback-based or the static analyzer checks. Follow up changes could make the other checks to skip header files and save more time.
• Add a --show-all-warnings flag. It is hidden, not shown by --help. When it is used, ClangTidyDiagnosticConsumer::checkFilters will not suppress any diagnostic message. This is useful to find tidy checks that have not yet handled the --skip-headers flag.
• Implementation Methods:
  • Factor out LocationFilter in ClangTidyDiagnosticConsumer
    • The skipLocation checks if a location should not be checked.
    • Use simple cache of the last skipped/accepted FileID to minimize the overhead of skipLocation.
  • Add a LocFilter to Tidy's MatchFinderOptions. In MatchASTVisitor::TraverseDecl and TraverseStmt, skip a sub-tree if the MatchFinderOptions has a LocFilter that decides to skip the location.
  • Add an AllFileFinder for checks that need to match all source files.
    • ForwardDeclarationNamespaceCheck is registered as an AllFileCheck, to avoid missing valid warnings on main source files.
    • UnusedUsingDeclsCheck is registered as an AllFileCheck, to avoid incorrect warnings on main source files.
    • Their diag functions call ClangTidyCheck::skipLocation to skip diagnostics on header files.
  • Depending on new changes to set/getTraversalScope in https://reviews.llvm.org/D104071, the AST was modified to exclude header file top-level Decls during the call to MatchFinder's ASTConsumer's HandleTranslationUnit.
    • AllFileFinder's and static analyzer's AST consumers are still called with the unmodified full AST.
    • ClangTidyASTConsumer overrides two member functions of MultiplexConsumer and accesses the Consumers data member.
      • in HandleTopLevelDecl to collect filtered Decls.
      • in HandleTranslationUnit to call get/setTraversalScope before calling the Finder ASTConcumser, which calls matchAST.
• Tests:
  • Add skip-headers*.cpp tests to show the effects of new flags.
  • Add bugprone-forward-declaration-namespace-header.cpp test to show how AllFileMatchFinder-based checks can depend on header Decls.
  • Add new test cases into misc-unused-using-decls.cpp.
  • Extend some clang-tidy checker tests to make sure that --skip-headers skips checks/warnings in the header files: google-namespaces.cpp modernize-pass-by-value-header.cpp
  • Add runs with --skip-headers in some clang-tidy checker tests to make sure that the option does not hide warnings in the main file:
    • about 18 other clang-tools-extra/test/clang-tidy/checkers/*.cpp
  • Some tests were added --skip-headers=0 flag to get expected warning messages in test header files: checkers/abseil-no-internal-dependencies.cpp checkers/abseil-upgrade-duration-conversions.cpp checkers/google-namespaces.cpp infrastructure/file-filter-symlinks.cpp infrastructure/file-filter.cpp infrastructure/line-filter.cpp
  • Some expected no-output lines in skip-headers-1 have FIXME, so they will pass test before the related PPCallbacks checks support the skip-headers option.

[chh]

Factor out LocationFilter; improve more tests.

[chh]

fix windows test failure

clang-tools-extra/clang-tidy/ClangTidy.cpp

private:
   FixBehaviour ApplyFixes;
   unsigned TotalFixes;
   unsigned AppliedFixes;
   unsigned WarningsAsErrors;
 };
 
 class ClangTidyASTConsumer : public MultiplexConsumer {
 public:
-  ClangTidyASTConsumer(std::vector<std::unique_ptr<ASTConsumer>> Consumers,
-                       std::unique_ptr<ClangTidyProfiling> Profiling,
-                       std::unique_ptr<ast_matchers::MatchFinder> Finder,
-                       std::vector<std::unique_ptr<ClangTidyCheck>> Checks)
+  ClangTidyASTConsumer(
+      std::vector<std::unique_ptr<ASTConsumer>> Consumers,
+      std::unique_ptr<ast_matchers::MatchFinder> AllFileFinder,
+      std::vector<std::unique_ptr<ClangTidyCheck>> Checks,
+      std::vector<std::unique_ptr<ClangTidyCheck>> AllFileChecks,
+      ASTConsumer *FinderASTConsumerPtr,
+      std::unique_ptr<ClangTidyLocationFilter> Filter)
       : MultiplexConsumer(std::move(Consumers)),
         Profiling(std::move(Profiling)), Finder(std::move(Finder)),
-        Checks(std::move(Checks)) {}
+        AllFileFinder(std::move(AllFileFinder)), Checks(std::move(Checks)),
+        AllFileChecks(std::move(AllFileChecks)),
+        FinderASTConsumerPtr(FinderASTConsumerPtr),
+        Filter(std::move(Filter)) {}
+  ~ClangTidyASTConsumer() override;
+  bool HandleTopLevelDecl(DeclGroupRef DG) override;
+  void HandleTranslationUnit(ASTContext &Context) override;
 
 private:
   // Destructor order matters! Profiling must be destructed last.
   // Or at least after Finder.
   std::unique_ptr<ClangTidyProfiling> Profiling;
   std::unique_ptr<ast_matchers::MatchFinder> Finder;
+  std::unique_ptr<ast_matchers::MatchFinder> AllFileFinder;
   std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
+  std::vector<std::unique_ptr<ClangTidyCheck>> AllFileChecks;
+
+  /// Remembered Finder's ASTConsumer, which is also pushed into
+  /// and managed by MultiplexConsumer.
+  ASTConsumer *FinderASTConsumerPtr;
+
+  // When --skip-headers, Filter is not null and handleTopLevelDecl
+  // will collect Decls into TopLevelDecls.
+  /// Check if a top level Decl should be skipped.
+  std::unique_ptr<ClangTidyLocationFilter> Filter;
+  /// All (filtered) top level decls.
+  std::vector<Decl *> TopLevelDecls;
 };
 
 } // namespace
 
 ClangTidyASTConsumerFactory::ClangTidyASTConsumerFactory(
     ClangTidyContext &Context,
     IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFS)
     : Context(Context), OverlayFS(std::move(OverlayFS)),
if (CheckName.startswith("core") ||
         Context.isCheckEnabled(ClangTidyCheckName)) {
       List.emplace_back(std::string(CheckName), true);
     }
   }
   return List;
 }
 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
 
+template <class T>
+bool isTemplateSpecializationKind(const NamedDecl *D,
+                                  TemplateSpecializationKind Kind) {
+  if (const auto *TD = dyn_cast<T>(D))
+    return TD->getTemplateSpecializationKind() == Kind;
+  return false;
+}
+
+bool isTemplateSpecializationKind(const NamedDecl *D,
+                                  TemplateSpecializationKind Kind) {
+  return isTemplateSpecializationKind<FunctionDecl>(D, Kind) ||
+         isTemplateSpecializationKind<CXXRecordDecl>(D, Kind) ||
+         isTemplateSpecializationKind<VarDecl>(D, Kind);
+}
+
+bool isImplicitTemplateInstantiation(const NamedDecl *D) {
+  return isTemplateSpecializationKind(D, TSK_ImplicitInstantiation);
+}
+
+ClangTidyASTConsumer::~ClangTidyASTConsumer() {}
+
+bool ClangTidyASTConsumer::HandleTopLevelDecl(DeclGroupRef DG) {
+  if (!MultiplexConsumer::HandleTopLevelDecl(DG))
+    return false;
+  if (Filter.get() != nullptr) {
+    for (Decl *D : DG) {
+      if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
+        if (isImplicitTemplateInstantiation(ND))
+          continue;
+      // ObjCMethodDecl are not actually top-level decls.
+      if (isa<ObjCMethodDecl>(D))
+        continue;
+      if (!Filter->skipLocation(D->getLocation()))
+        TopLevelDecls.push_back(D);
+    }
+  }
+  return true;
+}
+
+void ClangTidyASTConsumer::HandleTranslationUnit(ASTContext &Context) {
+  // If skip-headers is not on, there is no Filter and no skip TopLevelDecls.
+  // If there is no MatchFinder-based checks, FinderASTConsumerPtr is nullptr
+  // and there is no need to change TopLevelDecls.
+  if (Filter.get() != nullptr && nullptr != FinderASTConsumerPtr) {
+    for (auto &Consumer : Consumers) {
+      if (Consumer.get() == FinderASTConsumerPtr) {
+        const auto &SavedScope = Context.getTraversalScope();
+        Context.setTraversalScope(TopLevelDecls);
+        Consumer->HandleTranslationUnit(Context);
+        Context.setTraversalScope(SavedScope);
+      } else {
+        Consumer->HandleTranslationUnit(Context);
+      }
+    }
+  } else {
+    for (auto &Consumer : Consumers)
+      Consumer->HandleTranslationUnit(Context);
+  }
+}
+
 std::unique_ptr<clang::ASTConsumer>
 ClangTidyASTConsumerFactory::CreateASTConsumer(
     clang::CompilerInstance &Compiler, StringRef File) {
   // FIXME: Move this to a separate method, so that CreateASTConsumer doesn't
   // modify Compiler.
   SourceManager *SM = &Compiler.getSourceManager();
   Context.setSourceManager(SM);
   Context.setCurrentFile(File);
   Context.setASTContext(&Compiler.getASTContext());
 
   auto WorkingDir = Compiler.getSourceManager()
                         .getFileManager()
                         .getVirtualFileSystem()
                         .getCurrentWorkingDirectory();
   if (WorkingDir)
     Context.setCurrentBuildDirectory(WorkingDir.get());
 
   std::vector<std::unique_ptr<ClangTidyCheck>> Checks =
       CheckFactories->createChecks(&Context);
+  std::vector<std::unique_ptr<ClangTidyCheck>> AllFileChecks =
+      CheckFactories->createAllFileChecks(&Context);
 
-  llvm::erase_if(Checks, [&](std::unique_ptr<ClangTidyCheck> &Check) {
+  auto EraseFilter = [&](std::unique_ptr<ClangTidyCheck> &Check) {
     return !Check->isLanguageVersionSupported(Context.getLangOpts());
-  });
+  };
+  llvm::erase_if(Checks, EraseFilter);
+  llvm::erase_if(AllFileChecks, EraseFilter);
 
   ast_matchers::MatchFinder::MatchFinderOptions FinderOptions;
+  ast_matchers::MatchFinder::MatchFinderOptions AllFileFinderOptions;
 
   std::unique_ptr<ClangTidyProfiling> Profiling;
   if (Context.getEnableProfiling()) {
     Profiling = std::make_unique<ClangTidyProfiling>(
         Context.getProfileStorageParams());
+    // Two Finders share the same Profiling->Records.
     FinderOptions.CheckProfiling.emplace(Profiling->Records);
+    AllFileFinderOptions.CheckProfiling.emplace(Profiling->Records);
+  }
+
+  // LocationFilter is not for AllFileFinder.
+  if (*Context.getOptions().SkipHeaders) {
+    std::unique_ptr<ClangTidyLocationFilter> LocationFilter(
+        ClangTidyDiagnosticConsumer::newLocationFilter(&Context));
+    FinderOptions.Filter = std::move(LocationFilter);
   }
 
   std::unique_ptr<ast_matchers::MatchFinder> Finder(
       new ast_matchers::MatchFinder(std::move(FinderOptions)));
+  std::unique_ptr<ast_matchers::MatchFinder> AllFileFinder(
+      new ast_matchers::MatchFinder(std::move(AllFileFinderOptions)));
 
   Preprocessor *PP = &Compiler.getPreprocessor();
   Preprocessor *ModuleExpanderPP = PP;
 
   if (Context.getLangOpts().Modules && OverlayFS != nullptr) {
     auto ModuleExpander = std::make_unique<ExpandModularHeadersPPCallbacks>(
         &Compiler, OverlayFS);
     ModuleExpanderPP = ModuleExpander->getPreprocessor();
     PP->addPPCallbacks(std::move(ModuleExpander));
   }
 
   for (auto &Check : Checks) {
     Check->registerMatchers(&*Finder);
     Check->registerPPCallbacks(*SM, PP, ModuleExpanderPP);
   }
+  for (auto &Check : AllFileChecks) {
+    Check->registerMatchers(&*AllFileFinder);
+    Check->registerPPCallbacks(*SM, PP, ModuleExpanderPP);
+  }
 
   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
-  if (!Checks.empty())
-    Consumers.push_back(Finder->newASTConsumer());
+  ASTConsumer *FinderASTConsumerPtr = nullptr;
+  if (!Checks.empty()) {
+    std::unique_ptr<ASTConsumer> FinderASTConsumer(Finder->newASTConsumer());
+    FinderASTConsumerPtr = FinderASTConsumer.get();
+    Consumers.push_back(std::move(FinderASTConsumer));
+  }
+  if (!AllFileChecks.empty())
+    Consumers.push_back(AllFileFinder->newASTConsumer());
 
 #if CLANG_TIDY_ENABLE_STATIC_ANALYZER
   AnalyzerOptionsRef AnalyzerOptions = Compiler.getAnalyzerOpts();
   AnalyzerOptions->CheckersAndPackages = getAnalyzerCheckersAndPackages(
       Context, Context.canEnableAnalyzerAlphaCheckers());
   if (!AnalyzerOptions->CheckersAndPackages.empty()) {
     setStaticAnalyzerCheckerOpts(Context.getOptions(), *AnalyzerOptions);
     AnalyzerOptions->AnalysisStoreOpt = RegionStoreModel;
     AnalyzerOptions->AnalysisDiagOpt = PD_NONE;
     AnalyzerOptions->AnalyzeNestedBlocks = true;
     AnalyzerOptions->eagerlyAssumeBinOpBifurcation = true;
     std::unique_ptr<ento::AnalysisASTConsumer> AnalysisConsumer =
         ento::CreateAnalysisConsumer(Compiler);
     AnalysisConsumer->AddDiagnosticConsumer(
         new AnalyzerDiagnosticConsumer(Context));
     Consumers.push_back(std::move(AnalysisConsumer));
   }
 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
+  // TODO(chh): simplify creation of Filter;
+  std::unique_ptr<ClangTidyLocationFilter> Filter;
+  if (*Context.getOptions().SkipHeaders) {
+    std::unique_ptr<ClangTidyLocationFilter> LocationFilter(
+        ClangTidyDiagnosticConsumer::newLocationFilter(&Context));
+    Filter = std::move(LocationFilter);
+  }
   return std::make_unique<ClangTidyASTConsumer>(
       std::move(Consumers), std::move(Profiling), std::move(Finder),
-      std::move(Checks));
+      std::move(AllFileFinder), std::move(Checks), std::move(AllFileChecks),
+      FinderASTConsumerPtr, std::move(Filter));
 }
 
 std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
   std::vector<std::string> CheckNames;
   for (const auto &CheckFactory : *CheckFactories) {
     if (Context.isCheckEnabled(CheckFactory.getKey()))
       CheckNames.emplace_back(CheckFactory.getKey());
   }

 }
 
 ClangTidyOptions::OptionMap ClangTidyASTConsumerFactory::getCheckOptions() {
   ClangTidyOptions::OptionMap Options;
   std::vector<std::unique_ptr<ClangTidyCheck>> Checks =
       CheckFactories->createChecks(&Context);
   for (const auto &Check : Checks)
     Check->storeOptions(Options);
+  std::vector<std::unique_ptr<ClangTidyCheck>> AllFileChecks =
+      CheckFactories->createAllFileChecks(&Context);
+  for (const auto &Check : AllFileChecks)
+    Check->storeOptions(Options);
   return Options;
 }
 
 std::vector<std::string>
 getCheckNames(const ClangTidyOptions &Options,
               bool AllowEnablingAnalyzerAlphaCheckers) {
   clang::tidy::ClangTidyContext Context(
       std::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),

clang-tools-extra/clang-tidy/ClangTidyCheck.h

public:
 
   /// Should store all options supported by this check with their
   /// current values or default values for options that haven't been overridden.
   ///
   /// The check should use ``Options.store()`` to store each option it supports
   /// whether it has the default value or it has been overridden.
   virtual void storeOptions(ClangTidyOptions::OptionMap &Options) {}
 
+  /// Returns true if the Location should have warnings suppressed.
+  static bool skipLocation(SourceLocation Location) {
+    return ClangTidyDiagnosticConsumer::skipLocation(Location);
+  }
+
   /// Provides access to the ``ClangTidyCheck`` options via check-local
   /// names.
   ///
   /// Methods of this class prepend ``CheckName + "."`` to translate check-local
   /// option names to global option names.
   class OptionsView {
     void diagnoseBadIntegerOption(const Twine &Lookup,
                                   StringRef Unparsed) const;

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

 //===--- ClangTidyDiagnosticConsumer.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_CLANGTIDYDIAGNOSTICCONSUMER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
 
 #include "ClangTidyOptions.h"
 #include "ClangTidyProfiling.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Regex.h"
 
 namespace clang {
 
 class ASTContext;
 class CompilerInstance;
-class SourceManager;
-namespace ast_matchers {
-class MatchFinder;
-}
 namespace tooling {
 class CompilationDatabase;
 }
 
 namespace tidy {
 
 /// A detected error complete with information to display diagnostic and
 /// automatic fix.
public:
   DiagnosticBuilder diag(StringRef CheckName, StringRef Message,
                          DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
 
   /// Report any errors to do with reading the configuration using this method.
   DiagnosticBuilder
   configurationDiag(StringRef Message,
                     DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
 
+  /// Returns the \c SourceManager of the used \c DiagnosticsEngine.
+  SourceManager &getSourceManager() const {
+    return DiagEngine->getSourceManager();
+  }
+
   /// Sets the \c SourceManager of the used \c DiagnosticsEngine.
   ///
   /// This is called from the \c ClangTidyCheck base class.
   void setSourceManager(SourceManager *SourceMgr);
 
   /// Should be called when starting to process new translation unit.
   void setCurrentFile(StringRef File);
 
private:
   llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
 
   bool Profile;
   std::string ProfilePrefix;
 
   bool AllowEnablingAnalyzerAlphaCheckers;
 };
 
+typedef ast_matchers::MatchFinder::MatchFinderOptions::LocFilter
+    ClangTidyLocationFilter;
+
+class ClangTidyLocationFilterImpl;
+
 /// Check whether a given diagnostic should be suppressed due to the presence
 /// of a "NOLINT" suppression comment.
 /// This is exposed so that other tools that present clang-tidy diagnostics
 /// (such as clangd) can respect the same suppression rules as clang-tidy.
 /// This does not handle suppression of notes following a suppressed diagnostic;
 /// that is left to the caller is it requires maintaining state in between calls
 /// to this function.
 /// If `AllowIO` is false, the function does not attempt to read source files

 // FIXME: If we move away from unit-tests, this can be moved to a private
 // implementation file.
 class ClangTidyDiagnosticConsumer : public DiagnosticConsumer {
 public:
   ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx,
                               DiagnosticsEngine *ExternalDiagEngine = nullptr,
                               bool RemoveIncompatibleErrors = true,
                               bool GetFixesFromNotes = false);
+  ~ClangTidyDiagnosticConsumer();
 
   // FIXME: The concept of converting between FixItHints and Replacements is
   // more generic and should be pulled out into a more useful Diagnostics
   // library.
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                         const Diagnostic &Info) override;
 
   // Retrieve the diagnostics that were captured.
   std::vector<ClangTidyError> take();
 
+  /// Returns true if the Location should have warnings suppressed.
+  static bool skipLocation(SourceLocation Location) {
+    return LocationFilter && LocationFilter->skipLocation(Location);
+  }
+
+  static ClangTidyLocationFilter *newLocationFilter(ClangTidyContext *Context);
+
+  static ClangTidyLocationFilterImpl *
+  newLocationFilterImpl(ClangTidyContext *Context);
+
 private:
   void finalizeLastError();
   void removeIncompatibleErrors();
   void removeDuplicatedDiagnosticsOfAliasCheckers();
 
-  /// Returns the \c HeaderFilter constructed for the options set in the
-  /// context.
-  llvm::Regex *getHeaderFilter();
-
   /// Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
   /// according to the diagnostic \p Location.
   void checkFilters(SourceLocation Location, const SourceManager &Sources);
   bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
 
   void forwardDiagnostic(const Diagnostic &Info);
 
   ClangTidyContext &Context;
   DiagnosticsEngine *ExternalDiagEngine;
   bool RemoveIncompatibleErrors;
   bool GetFixesFromNotes;
   std::vector<ClangTidyError> Errors;
-  std::unique_ptr<llvm::Regex> HeaderFilter;
+  std::unique_ptr<ClangTidyLocationFilterImpl> LocationFilterImpl;
   bool LastErrorRelatesToUserCode;
   bool LastErrorPassesLineFilter;
   bool LastErrorWasIgnored;
+
+  static std::unique_ptr<ClangTidyLocationFilter> LocationFilter;
 };
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Regex.h"
 #include <tuple>
 #include <vector>
 using namespace clang;
 using namespace tidy;
 
+namespace clang {
+namespace tidy {
+
+class ClangTidyLocationFilterImpl : ClangTidyLocationFilter {
+public:
+  ClangTidyLocationFilterImpl(ClangTidyContext *Context);
+  ~ClangTidyLocationFilterImpl();
+  virtual bool skipLocation(SourceLocation Location) const override;
+
+private:
+  friend class ClangTidyDiagnosticConsumer;
+  /// Returns true if the Location with FileID is in a skipped system header.
+  bool isSkippedSystemHeader(SourceLocation Location, FileID FileID,
+                             const FileEntry *File,
+                             const SourceManager &Sources) const;
+
+  /// Returns true if the Location with FileID is in user code.
+  bool isUserCode(SourceLocation Location, FileID FileID, const FileEntry *File,
+                  const SourceManager &Sources) const;
+
+  ClangTidyContext *Context;
+  mutable FileID LastSkippedSystemFileID;
+  mutable FileID LastSkippedFileID;
+  mutable FileID LastAcceptedFileID;
+  std::unique_ptr<llvm::Regex> HeaderFilterRegex;
+};
+
+} // end namespace tidy
+} // end namespace clang
+
+ClangTidyLocationFilterImpl::~ClangTidyLocationFilterImpl() = default;
+
+ClangTidyLocationFilterImpl::ClangTidyLocationFilterImpl(
+    ClangTidyContext *Context)
+    : Context(Context), LastSkippedSystemFileID(FileID::getSentinel()),
+      LastSkippedFileID(FileID::getSentinel()),
+      LastAcceptedFileID(FileID::getSentinel()),
+      HeaderFilterRegex(std::make_unique<llvm::Regex>(
+          *Context->getOptions().HeaderFilterRegex)) {}
+
+bool ClangTidyLocationFilterImpl::skipLocation(SourceLocation Location) const {
+  if (!Location.isValid())
+    return false;
+  SourceManager &Sources = Context->getSourceManager();
+  FileID FID = Sources.getDecomposedExpansionLoc(Location).first;
+  // Do not skip built-in and command line yet.
+  const FileEntry *File = Sources.getFileEntryForID(FID);
+  if (!File)
+    return false;
+  return isSkippedSystemHeader(Location, FID, File, Sources) ||
+         !isUserCode(Location, FID, File, Sources);
+}
+
+bool ClangTidyLocationFilterImpl::isSkippedSystemHeader(
+    SourceLocation Location, FileID FID, const FileEntry *File,
+    const SourceManager &Sources) const {
+  if (!File)
+    return false;
+  if (FID == LastSkippedSystemFileID)
+    return true;
+  if (!*Context->getOptions().SystemHeaders &&
+      Sources.isInSystemHeader(Location)) {
+    LastSkippedSystemFileID = FID;
+    return true;
+  }
+  return false;
+}
+
+bool ClangTidyLocationFilterImpl::isUserCode(
+    SourceLocation Location, FileID FID, const FileEntry *File,
+    const SourceManager &Sources) const {
+  assert(File);
+  if (FID == LastSkippedFileID)
+    return false;
+  if (FID == LastAcceptedFileID)
+    return true;
+  bool IsUserCode = Sources.isInMainFile(Location) ||
+                    HeaderFilterRegex->match(File->getName());
+  if (IsUserCode)
+    LastAcceptedFileID = FID;
+  else
+    LastSkippedFileID = FID;
+  return IsUserCode;
+}
+
 namespace {
 class ClangTidyDiagnosticRenderer : public DiagnosticRenderer {
 public:
   ClangTidyDiagnosticRenderer(const LangOptions &LangOpts,
                               DiagnosticOptions *DiagOpts,
                               ClangTidyError &Error)
       : DiagnosticRenderer(LangOpts, DiagOpts), Error(Error) {}
 
if (!ClangWarningOption.empty())
     return "clang-diagnostic-" + ClangWarningOption;
   llvm::DenseMap<unsigned, std::string>::const_iterator I =
       CheckNamesByDiagnosticID.find(DiagnosticID);
   if (I != CheckNamesByDiagnosticID.end())
     return I->second;
   return "";
 }
 
+// Global LocationFilter is non-null if --skip-header is enabled.
+std::unique_ptr<ClangTidyLocationFilter>
+    ClangTidyDiagnosticConsumer::LocationFilter;
+
 ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(
     ClangTidyContext &Ctx, DiagnosticsEngine *ExternalDiagEngine,
     bool RemoveIncompatibleErrors, bool GetFixesFromNotes)
     : Context(Ctx), ExternalDiagEngine(ExternalDiagEngine),
       RemoveIncompatibleErrors(RemoveIncompatibleErrors),
-      GetFixesFromNotes(GetFixesFromNotes), LastErrorRelatesToUserCode(false),
-      LastErrorPassesLineFilter(false), LastErrorWasIgnored(false) {}
+      GetFixesFromNotes(GetFixesFromNotes),
+      LocationFilterImpl(newLocationFilterImpl(&Ctx)),
+      LastErrorRelatesToUserCode(false), LastErrorPassesLineFilter(false),
+      LastErrorWasIgnored(false) {
+  if (*Ctx.getOptions().SkipHeaders)
+    LocationFilter =
+        std::unique_ptr<ClangTidyLocationFilter>(newLocationFilter(&Ctx));
+}
+
+ClangTidyLocationFilterImpl *
+ClangTidyDiagnosticConsumer::newLocationFilterImpl(ClangTidyContext *Context) {
+  return new ClangTidyLocationFilterImpl(Context);
+}
+
+ClangTidyLocationFilter *
+ClangTidyDiagnosticConsumer::newLocationFilter(ClangTidyContext *Context) {
+  return new ClangTidyLocationFilterImpl(Context);
+}
+
+ClangTidyDiagnosticConsumer::~ClangTidyDiagnosticConsumer() = default;
 
 void ClangTidyDiagnosticConsumer::finalizeLastError() {
   if (!Errors.empty()) {
     ClangTidyError &Error = Errors.back();
     if (Error.DiagnosticName == "clang-tidy-config") {
       // Never ignore these.
     } else if (!Context.isCheckEnabled(Error.DiagnosticName) &&
                Error.DiagLevel != ClangTidyError::Error) {
case clang::DiagnosticsEngine::ak_addrspace:
       break;
     }
   }
 }
 
 void ClangTidyDiagnosticConsumer::checkFilters(SourceLocation Location,
                                                const SourceManager &Sources) {
   // Invalid location may mean a diagnostic in a command line, don't skip these.
-  if (!Location.isValid()) {
+  if (!Location.isValid() || *Context.getOptions().ShowAllWarnings) {
     LastErrorRelatesToUserCode = true;
     LastErrorPassesLineFilter = true;
     return;
   }
 
-  if (!*Context.getOptions().SystemHeaders &&
-      Sources.isInSystemHeader(Location))
-    return;
-
   // FIXME: We start with a conservative approach here, but the actual type of
   // location needed depends on the check (in particular, where this check wants
   // to apply fixes).
   FileID FID = Sources.getDecomposedExpansionLoc(Location).first;
   const FileEntry *File = Sources.getFileEntryForID(FID);
+  if (LocationFilterImpl->isSkippedSystemHeader(Location, FID, File, Sources))
+    return;
 
   // -DMACRO definitions on the command line have locations in a virtual buffer
   // that doesn't have a FileEntry. Don't skip these as well.
   if (!File) {
     LastErrorRelatesToUserCode = true;
     LastErrorPassesLineFilter = true;
     return;
   }
 
   StringRef FileName(File->getName());
-  LastErrorRelatesToUserCode = LastErrorRelatesToUserCode ||
-                               Sources.isInMainFile(Location) ||
-                               getHeaderFilter()->match(FileName);
+  LastErrorRelatesToUserCode =
+      LastErrorRelatesToUserCode ||
+      LocationFilterImpl->isUserCode(Location, FID, File, Sources);
 
   unsigned LineNumber = Sources.getExpansionLineNumber(Location);
   LastErrorPassesLineFilter =
       LastErrorPassesLineFilter || passesLineFilter(FileName, LineNumber);
 }
 
-llvm::Regex *ClangTidyDiagnosticConsumer::getHeaderFilter() {
-  if (!HeaderFilter)
-    HeaderFilter =
-        std::make_unique<llvm::Regex>(*Context.getOptions().HeaderFilterRegex);
-  return HeaderFilter.get();
-}
-
 void ClangTidyDiagnosticConsumer::removeIncompatibleErrors() {
   // Each error is modelled as the set of intervals in which it applies
   // replacements. To detect overlapping replacements, we use a sweep line
   // algorithm over these sets of intervals.
   // An event here consists of the opening or closing of an interval. During the
   // process, we maintain a counter with the amount of open intervals. If we
   // find an endpoint of an interval and this counter is different from 0, it
   // means that this interval overlaps with another one, so we set it as

clang-tools-extra/clang-tidy/ClangTidyModule.h

 class ClangTidyCheckFactories {
 public:
   using CheckFactory = std::function<std::unique_ptr<ClangTidyCheck>(
       llvm::StringRef Name, ClangTidyContext *Context)>;
 
   /// Registers check \p Factory with name \p Name.
   ///
   /// For all checks that have default constructors, use \c registerCheck.
-  void registerCheckFactory(llvm::StringRef Name, CheckFactory Factory);
+  void registerCheckFactory(llvm::StringRef Name, CheckFactory Factory,
+                            bool IsAllFileCheck = false);
 
   /// Registers the \c CheckType with the name \p Name.
   ///
   /// This method should be used for all \c ClangTidyChecks that don't require
   /// constructor parameters.
   ///
   /// For example, if have a clang-tidy check like:
   /// \code
   /// class MyTidyCheck : public ClangTidyCheck {
   ///   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
   ///     ..
   ///   }
   /// };
   /// \endcode
   /// you can register it with:
   /// \code
   /// class MyModule : public ClangTidyModule {
   ///   void addCheckFactories(ClangTidyCheckFactories &Factories) override {
   ///     Factories.registerCheck<MyTidyCheck>("myproject-my-check");
+  ///     // or Factories.registerCheck<MyTidyCheck>("my-check", true);
+  ///     // for a check that needs to match all Decls in header files.
   ///   }
   /// };
   /// \endcode
-  template <typename CheckType> void registerCheck(llvm::StringRef CheckName) {
-    registerCheckFactory(CheckName,
-                         [](llvm::StringRef Name, ClangTidyContext *Context) {
-                           return std::make_unique<CheckType>(Name, Context);
-                         });
+  template <typename CheckType>
+  void registerCheck(llvm::StringRef CheckName, bool IsAllFileCheck = false) {
+    registerCheckFactory(
+        CheckName,
+        },
+        IsAllFileCheck);
   }
 
   /// Create instances of checks that are enabled.
   std::vector<std::unique_ptr<ClangTidyCheck>>
   createChecks(ClangTidyContext *Context);
 
+  /// Create instances of all-file checks that are enabled.
+  std::vector<std::unique_ptr<ClangTidyCheck>>
+  createAllFileChecks(ClangTidyContext *Context);
+
   typedef llvm::StringMap<CheckFactory> FactoryMap;
   FactoryMap::const_iterator begin() const { return Factories.begin(); }
   FactoryMap::const_iterator end() const { return Factories.end(); }
   bool empty() const { return Factories.empty(); }
 
 private:
-  FactoryMap Factories;
+  FactoryMap Factories; // has both normal checks and all-file checks
+  llvm::StringMap<bool> IsAllFileChecks; // check name -> is all-file check
 };
 
 /// A clang-tidy module groups a number of \c ClangTidyChecks and gives
 /// them a prefixed name.
 class ClangTidyModule {
 public:
   virtual ~ClangTidyModule() {}
 

clang-tools-extra/clang-tidy/ClangTidyModule.cpp

 
 #include "ClangTidyModule.h"
 #include "ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 
 void ClangTidyCheckFactories::registerCheckFactory(StringRef Name,
-                                                   CheckFactory Factory) {
+                                                   CheckFactory Factory,
+                                                   bool IsAllFileCheck) {
   Factories.insert_or_assign(Name, std::move(Factory));
+  IsAllFileChecks.insert_or_assign(Name, IsAllFileCheck);
 }
 
 std::vector<std::unique_ptr<ClangTidyCheck>>
 ClangTidyCheckFactories::createChecks(ClangTidyContext *Context) {
   std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
   for (const auto &Factory : Factories) {
-    if (Context->isCheckEnabled(Factory.getKey()))
+    if (Context->isCheckEnabled(Factory.getKey()) &&
+        !IsAllFileChecks[Factory.getKey()])
       Checks.emplace_back(Factory.getValue()(Factory.getKey(), Context));
   }
   return Checks;
 }
 
+std::vector<std::unique_ptr<ClangTidyCheck>>
+ClangTidyCheckFactories::createAllFileChecks(ClangTidyContext *Context) {
+  std::vector<std::unique_ptr<ClangTidyCheck>> AllFileChecks;
+  for (const auto &Factory : Factories) {
+    if (Context->isCheckEnabled(Factory.getKey()) &&
+        IsAllFileChecks[Factory.getKey()])
+      AllFileChecks.emplace_back(Factory.getValue()(Factory.getKey(), Context));
+  }
+  return AllFileChecks;
+}
+
 ClangTidyOptions ClangTidyModule::getModuleOptions() {
   return ClangTidyOptions();
 }
 
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/ClangTidyOptions.h

struct ClangTidyOptions {
 
   /// Output warnings from headers matching this filter. Warnings from
   /// main files will always be displayed.
   llvm::Optional<std::string> HeaderFilterRegex;
 
   /// Output warnings from system headers matching \c HeaderFilterRegex.
   llvm::Optional<bool> SystemHeaders;
 
+  /// Show all warnings, including warnings from all header files.
+  /// This overrides HeaderFilterRegex and SystemHeaders.
+  /// This is an option intended for testing/debugging clang-tidy.
+  llvm::Optional<bool> ShowAllWarnings;
+
+  /// Do not check included files, except files matching the --header-filter
+  /// and system files when --system-headers is used.
+  llvm::Optional<bool> SkipHeaders;
+
   /// Format code around applied fixes with clang-format using this
   /// style.
   ///
   /// Can be one of:
   ///   * 'none' - don't format code around applied fixes;
   ///   * 'llvm', 'google', 'mozilla' or other predefined clang-format style
   ///     names;
   ///   * 'file' - use the .clang-format file in the closest parent directory of

clang-tools-extra/clang-tidy/ClangTidyOptions.cpp

 template <> struct MappingTraits<ClangTidyOptions> {
   static void mapping(IO &IO, ClangTidyOptions &Options) {
     MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
         IO, Options.CheckOptions);
     bool Ignored = false;
     IO.mapOptional("Checks", Options.Checks);
     IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
     IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
+    // SystemHeaders not mapped?
+    // ShowAllWarnings is hidden debug only option.
+    IO.mapOptional("SkipHeaders", Options.SkipHeaders);
     IO.mapOptional("AnalyzeTemporaryDtors", Ignored); // legacy compatibility
     IO.mapOptional("FormatStyle", Options.FormatStyle);
     IO.mapOptional("User", Options.User);
     IO.mapOptional("CheckOptions", NOpts->Options);
     IO.mapOptional("ExtraArgs", Options.ExtraArgs);
     IO.mapOptional("ExtraArgsBefore", Options.ExtraArgsBefore);
     IO.mapOptional("InheritParentConfig", Options.InheritParentConfig);
     IO.mapOptional("UseColor", Options.UseColor);
   }
 };
 
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace tidy {
 
 ClangTidyOptions ClangTidyOptions::getDefaults() {
   ClangTidyOptions Options;
   Options.Checks = "";
   Options.WarningsAsErrors = "";
   Options.HeaderFilterRegex = "";
+  Options.ShowAllWarnings = false;
+  Options.SkipHeaders = false;
   Options.SystemHeaders = false;
   Options.FormatStyle = "none";
   Options.User = llvm::None;
   for (const ClangTidyModuleRegistry::entry &Module :
        ClangTidyModuleRegistry::entries())
     Options.mergeWith(Module.instantiate()->getModuleOptions(), 0);
   return Options;
 }
if (Src)
     Dest = Src;
 }
 
 ClangTidyOptions &ClangTidyOptions::mergeWith(const ClangTidyOptions &Other,
                                               unsigned Order) {
   mergeCommaSeparatedLists(Checks, Other.Checks);
   mergeCommaSeparatedLists(WarningsAsErrors, Other.WarningsAsErrors);
   overrideValue(HeaderFilterRegex, Other.HeaderFilterRegex);
+  overrideValue(ShowAllWarnings, Other.ShowAllWarnings);
+  overrideValue(SkipHeaders, Other.SkipHeaders);
   overrideValue(SystemHeaders, Other.SystemHeaders);
   overrideValue(FormatStyle, Other.FormatStyle);
   overrideValue(User, Other.User);
   overrideValue(UseColor, Other.UseColor);
   mergeVectors(ExtraArgs, Other.ExtraArgs);
   mergeVectors(ExtraArgsBefore, Other.ExtraArgsBefore);
 
   for (const auto &KeyValue : Other.CheckOptions) {

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

CheckFactories.registerCheck<DynamicStaticInitializersCheck>(
         "bugprone-dynamic-static-initializers");
     CheckFactories.registerCheck<EasilySwappableParametersCheck>(
         "bugprone-easily-swappable-parameters");
     CheckFactories.registerCheck<ExceptionEscapeCheck>(
         "bugprone-exception-escape");
     CheckFactories.registerCheck<FoldInitTypeCheck>(
         "bugprone-fold-init-type");
     CheckFactories.registerCheck<ForwardDeclarationNamespaceCheck>(
-        "bugprone-forward-declaration-namespace");
+        "bugprone-forward-declaration-namespace", true);
     CheckFactories.registerCheck<ForwardingReferenceOverloadCheck>(
         "bugprone-forwarding-reference-overload");
     CheckFactories.registerCheck<ImplicitWideningOfMultiplicationResultCheck>(
         "bugprone-implicit-widening-of-multiplication-result");
     CheckFactories.registerCheck<InaccurateEraseCheck>(
         "bugprone-inaccurate-erase");
     CheckFactories.registerCheck<IncorrectRoundingsCheck>(
         "bugprone-incorrect-roundings");

clang-tools-extra/clang-tidy/bugprone/ForwardDeclarationNamespaceCheck.cpp

for (const auto *CurDecl : Declarations) {
       }
       if (FriendTypes.count(CurDecl->getTypeForDecl()) != 0) {
         continue; // Skip forward declarations referenced as friend.
       }
       if (CurDecl->getLocation().isMacroID() ||
           CurDecl->getLocation().isInvalid()) {
         continue;
       }
+      if (skipLocation(CurDecl->getLocation())) {
+        continue; // Skip if --skip-headers and CurDecl's file is skipped.
+      }
       // Compare with all other declarations with the same name.
       for (const auto *Decl : Declarations) {
         if (Decl == CurDecl) {
           continue; // Don't compare with self.
         }
         if (!CurDecl->hasDefinition() &&
             !haveSameNamespaceOrTranslationUnit(CurDecl, Decl)) {
           diag(CurDecl->getLocation(),

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

CheckFactories.registerCheck<UnconventionalAssignOperatorCheck>(
         "misc-unconventional-assign-operator");
     CheckFactories.registerCheck<UniqueptrResetReleaseCheck>(
         "misc-uniqueptr-reset-release");
     CheckFactories.registerCheck<UnusedAliasDeclsCheck>(
         "misc-unused-alias-decls");
     CheckFactories.registerCheck<UnusedParametersCheck>(
         "misc-unused-parameters");
     CheckFactories.registerCheck<UnusedUsingDeclsCheck>(
-        "misc-unused-using-decls");
+        "misc-unused-using-decls", true);
   }
 };
 
 } // namespace misc
 
 // Register the MiscTidyModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<misc::MiscModule>
     X("misc-module", "Adds miscellaneous lint checks.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the MiscModule.
 volatile int MiscModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

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

void UnusedUsingDeclsCheck::removeFromFoundDecls(const Decl *D) {
   for (auto &Context : Contexts) {
     if (Context.UsingTargetDecls.count(D->getCanonicalDecl()) > 0)
       Context.IsUsed = true;
   }
 }
 
 void UnusedUsingDeclsCheck::onEndOfTranslationUnit() {
   for (const auto &Context : Contexts) {
-    if (!Context.IsUsed) {
+    if (!Context.IsUsed &&
+        !skipLocation(Context.FoundUsingDecl->getLocation())) {
       diag(Context.FoundUsingDecl->getLocation(), "using decl %0 is unused")
           << Context.FoundUsingDecl;
       // Emit a fix and a fix description of the check;
       diag(Context.FoundUsingDecl->getLocation(),
            /*Description=*/"remove the using", DiagnosticIDs::Note)
           << FixItHint::CreateRemoval(Context.UsingDeclRange);
     }
   }
   Contexts.clear();
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.cpp

if (auto *E = dyn_cast<CXXDefaultArgExpr>(S)) {
       C = dyn_cast<CastExpr>(E->getExpr());
       FirstSubExpr = nullptr;
     }
     if (!C) {
       FirstSubExpr = nullptr;
       return true;
     }
 
+    // When Stmt S does not have a "valid" location,
+    // skipLocation won't skip it.
+    // So we need to check here if C should be skipped.
+    if (Check.skipLocation(C->getBeginLoc()))
+      return true;
+
     auto* CastSubExpr = C->getSubExpr()->IgnoreParens();
     // Ignore cast expressions which cast nullptr literal.
     if (isa<CXXNullPtrLiteralExpr>(CastSubExpr)) {
       return true;
     }
 
     if (!FirstSubExpr)
       FirstSubExpr = CastSubExpr;

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

 always displayed.
 Can be used together with -line-filter.
 This option overrides the 'HeaderFilterRegex'
 option in .clang-tidy file, if any.
 )"),
                                          cl::init(""),
                                          cl::cat(ClangTidyCategory));
 
+static cl::opt<bool> ShowAllWarnings("show-all-warnings",
+                                     cl::desc("Display all warning messages."),
+                                     cl::init(false), cl::Hidden,
+                                     cl::cat(ClangTidyCategory));
+
+static cl::opt<bool> SkipHeaders("skip-headers", cl::desc(R"(
+Do not check included header files, but
+files matching the --header-filter pattern are still checked.
+System headers are still checked if --system-headers is true.
+)"),
+                                 cl::init(false), cl::cat(ClangTidyCategory));
+
 static cl::opt<bool>
     SystemHeaders("system-headers",
                   cl::desc("Display the errors from system headers."),
                   cl::init(false), cl::cat(ClangTidyCategory));
+
 static cl::opt<std::string> LineFilter("line-filter", cl::desc(R"(
 List of files with line ranges to filter the
 warnings. Can be used together with
 -header-filter. The format of the list is a
 JSON array of objects:
   [
     {"name":"file1.cpp","lines":[[1,3],[5,7]]},
     {"name":"file2.h"}
if (std::error_code Err = parseLineFilter(LineFilter, GlobalOptions)) {
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return nullptr;
   }
 
   ClangTidyOptions DefaultOptions;
   DefaultOptions.Checks = DefaultChecks;
   DefaultOptions.WarningsAsErrors = "";
   DefaultOptions.HeaderFilterRegex = HeaderFilter;
+  DefaultOptions.ShowAllWarnings = ShowAllWarnings;
+  DefaultOptions.SkipHeaders = SkipHeaders;
   DefaultOptions.SystemHeaders = SystemHeaders;
   DefaultOptions.FormatStyle = FormatStyle;
   DefaultOptions.User = llvm::sys::Process::GetEnv("USER");
   // USERNAME is used on Windows.
   if (!DefaultOptions.User)
     DefaultOptions.User = llvm::sys::Process::GetEnv("USERNAME");
 
   ClangTidyOptions OverrideOptions;
   if (Checks.getNumOccurrences() > 0)
     OverrideOptions.Checks = Checks;
   if (WarningsAsErrors.getNumOccurrences() > 0)
     OverrideOptions.WarningsAsErrors = WarningsAsErrors;
   if (HeaderFilter.getNumOccurrences() > 0)
     OverrideOptions.HeaderFilterRegex = HeaderFilter;
+  if (ShowAllWarnings.getNumOccurrences() > 0)
+    OverrideOptions.ShowAllWarnings = ShowAllWarnings;
+  if (SkipHeaders.getNumOccurrences() > 0)
+    OverrideOptions.SkipHeaders = SkipHeaders;
   if (SystemHeaders.getNumOccurrences() > 0)
     OverrideOptions.SystemHeaders = SystemHeaders;
   if (FormatStyle.getNumOccurrences() > 0)
     OverrideOptions.FormatStyle = FormatStyle;
   if (UseColor.getNumOccurrences() > 0)
     OverrideOptions.UseColor = UseColor;
 
   auto LoadConfig =

clang-tools-extra/test/clang-tidy/checkers/Inputs/bugprone-forward-declaration-namespace/a.h

+namespace {
+// This is a declaration in a wrong namespace.
+class T_A;
+} // namespace
+
+namespace na {
+// This is a declaration in a wrong namespace.
+class T_A;
+} // namespace na

clang-tools-extra/test/clang-tidy/checkers/Inputs/bugprone-forward-declaration-namespace/b.h

+namespace nb {
+class T_B;
+}
+
+namespace nb {
+class T_B {
+  int x;
+};
+} // namespace nb

clang-tools-extra/test/clang-tidy/checkers/Inputs/modernize-pass-by-value/header.h

 class ThreadId {
 public:
   ThreadId(const ThreadId &) {}
   ThreadId(ThreadId &&) {}
 };
 
 struct A {
   A(const ThreadId &tid) : threadid(tid) {}
   ThreadId threadid;
 };
+
+struct Movable {
+  int a, b, c;
+  Movable() = default;
+  Movable(const Movable &) {}
+  Movable(Movable &&) {}
+};

clang-tools-extra/test/clang-tidy/checkers/Inputs/skip-headers/a.h

+class A {
+#include "b.h"
+  void fooA(int x) { x = 1; };
+};

clang-tools-extra/test/clang-tidy/checkers/Inputs/skip-headers/b.h

+class B {
+  // expect a warning on fooB
+  void fooB(int x) { x = 2; };
+};

clang-tools-extra/test/clang-tidy/checkers/Inputs/skip-headers/c.h

+template <class T>
+class C {
+public:
+  template <class R>
+  explicit C(const R r, int *x = 0) : p(x) {}
+
+private:
+  int *p;
+};

clang-tools-extra/test/clang-tidy/checkers/Inputs/skip-headers/c1.h

+#ifndef C1_H_
+#define C1_H_
+
+struct C1 {
+  static int foo1(int n = 1ll);
+  int foo2(int n = 2ll);
+  int foo3(int n);
+};
+
+#endif // C1_H_

clang-tools-extra/test/clang-tidy/checkers/Inputs/skip-headers/my_header1.h

+// no header guard
+
+#include "my_header2.h"

clang-tools-extra/test/clang-tidy/checkers/Inputs/skip-headers/my_header2.h

+// bad header guard
+#ifndef SOME_MACRO
+
+int abc = 123; // bad definition in .h file
+
+#endif

clang-tools-extra/test/clang-tidy/checkers/Inputs/unused-using-decls.h

 class MyClass {
 public:
   template <template <typename> class S, typename T>
   S<T> *func1(T *a) {
     return new S<T>();
   }
   template <typename T, T (*S)()>
   void func2(T a) {
     S();
   }
 };
+
+QC1 *foo();
+
+namespace Q2 {
+class QC2 {};
+} // namespace Q2
+using Q2::QC2;
+// not used QC2 should have warning only when .h file is selected with --header-filter

clang-tools-extra/test/clang-tidy/checkers/abseil-no-internal-dependencies.cpp

-// RUN: %check_clang_tidy %s abseil-no-internal-dependencies %t,  -- -- -I %S/Inputs
-// RUN: clang-tidy -checks='-*, abseil-no-internal-dependencies' -header-filter='.*' %s -- -I %S/Inputs 2>&1 | FileCheck %s
+// RUN: %check_clang_tidy %s abseil-no-internal-dependencies %t,  -- --skip-headers=0 -- -I %S/Inputs
+// RUN: clang-tidy --skip-headers=0 -checks='-*, abseil-no-internal-dependencies' -header-filter='.*' %s -- -I %S/Inputs 2>&1 | FileCheck %s
 
 #include "absl/strings/internal-file.h"
 #include "absl/flags/internal-file.h"
 // CHECK-NOT: warning:
 
 #include "absl/external-file.h"
 // CHECK: absl/external-file.h:6:24: warning: do not reference any 'internal' namespaces; those implementation details are reserved to Abseil [abseil-no-internal-dependencies]
 

clang-tools-extra/test/clang-tidy/checkers/abseil-upgrade-duration-conversions.cpp

-// RUN: %check_clang_tidy -std=c++11-or-later %s abseil-upgrade-duration-conversions %t -- -- -I%S/Inputs
+// RUN: %check_clang_tidy -std=c++11-or-later %s abseil-upgrade-duration-conversions %t -- --skip-headers=0 -- -I%S/Inputs
+// RUN: %check_clang_tidy -std=c++11-or-later %s abseil-upgrade-duration-conversions %t -- --skip-headers -- -I%S/Inputs
 
 using int64_t = long long;
 
 #include "absl/time/time.h"
 
 template <typename T> struct ConvertibleTo {
   operator T() const;
 };

clang-tools-extra/test/clang-tidy/checkers/bugprone-forward-declaration-namespace-header.cpp

+// Same output with skip-headers=0, skip-headers=1, or skip-headers
+//
+// With --skip-headers=0 and no --header-filter, there should be no warning
+// shown for a.h or b.h. But there seems to be a bug and we are seeing the A1 warnings.
+// RUN: %check_clang_tidy -check-suffixes=ALL,A1 %s bugprone-forward-declaration-namespace %t -- --skip-headers=0 \
+// RUN:   -- -I%S/Inputs/bugprone-forward-declaration-namespace
+// RUN: %check_clang_tidy -check-suffixes=ALL %s bugprone-forward-declaration-namespace %t -- --skip-headers=1 \
+// RUN:   -- -I%S/Inputs/bugprone-forward-declaration-namespace
+// RUN: %check_clang_tidy -check-suffixes=ALL %s bugprone-forward-declaration-namespace %t -- --skip-headers \
+// RUN:   -- -I%S/Inputs/bugprone-forward-declaration-namespace
+//
+// Same output with header-filter=b.h because there is no warning on b.h
+// RUN: %check_clang_tidy -check-suffixes=ALL %s bugprone-forward-declaration-namespace %t -- --skip-headers \
+// RUN:   --header-filter=b.h -- -I%S/Inputs/bugprone-forward-declaration-namespace
+//
+// With --header-filter, we should see all warnings from a.h.
+// RUN: %check_clang_tidy -check-suffixes=ALL,A,A1 %s bugprone-forward-declaration-namespace %t -- --skip-headers=0 \
+// RUN:   --header-filter=.* -- -I%S/Inputs/bugprone-forward-declaration-namespace
+// RUN: %check_clang_tidy -check-suffixes=ALL,A,A1 %s bugprone-forward-declaration-namespace %t -- --skip-headers \
+// RUN:   --header-filter=.* -- -I%S/Inputs/bugprone-forward-declaration-namespace
+// RUN: %check_clang_tidy -check-suffixes=ALL,A,A1 %s bugprone-forward-declaration-namespace %t -- --skip-headers=0 \
+// RUN:   --header-filter=a.h -- -I%S/Inputs/bugprone-forward-declaration-namespace
+// RUN: %check_clang_tidy -check-suffixes=ALL,A,A1 %s bugprone-forward-declaration-namespace %t -- --skip-headers \
+// RUN:   --header-filter=a.h -- -I%S/Inputs/bugprone-forward-declaration-namespace
+
+#include "a.h"
+
+class T_A;
+
+class T_A {
+  int x;
+};
+
+class NESTED;
+// CHECK-NOTES-ALL: :[[@LINE-1]]:7: warning: no definition found for 'NESTED', but a definition with the same name 'NESTED' found in another namespace '(anonymous namespace)::nq::(anonymous)'
+// CHECK-NOTES-ALL: note: a definition of 'NESTED' is found here
+
+namespace {
+namespace nq {
+namespace {
+class NESTED {};
+} // namespace
+} // namespace nq
+} // namespace
+
+namespace na {
+class T_B;
+// CHECK-NOTES-ALL: :[[@LINE-1]]:7: warning: declaration 'T_B' is never referenced, but a declaration with the same name found in another namespace 'nb'
+// CHECK-NOTES-ALL: note: a declaration of 'T_B' is found here
+// CHECK-NOTES-ALL: :[[@LINE-3]]:7: warning: no definition found for 'T_B', but a definition with the same name 'T_B' found in another namespace 'nb'
+// CHECK-NOTES-ALL: note: a definition of 'T_B' is found here
+} // namespace na
+
+#include "b.h"
+
+namespace na {
+class T_B;
+// CHECK-NOTES-ALL: :[[@LINE-1]]:7: warning: declaration 'T_B' is never referenced, but a declaration with the same name found in another namespace 'nb'
+// CHECK-NOTES-ALL: note: a declaration of 'T_B' is found here
+// CHECK-NOTES-ALL: :[[@LINE-3]]:7: warning: no definition found for 'T_B', but a definition with the same name 'T_B' found in another namespace 'nb'
+// CHECK-NOTES-ALL: note: a definition of 'T_B' is found here
+} // namespace na
+
+// A simple forward declaration. Although it is never used, but no declaration
+// with the same name is found in other namespace.
+class OUTSIDER;
+
+namespace na {
+// This class is referenced declaration, we don't generate warning.
+class OUTSIDER_1;
+} // namespace na
+
+void f(na::OUTSIDER_1);
+
+namespace nc {
+// This class is referenced as friend in OOP.
+class OUTSIDER_1;
+
+class OOP {
+  friend struct OUTSIDER_1;
+};
+} // namespace nc
+
+namespace nd {
+class OUTSIDER_1;
+void f(OUTSIDER_1 *);
+} // namespace nd
+
+namespace nb {
+class OUTSIDER_1;
+// CHECK-NOTES-ALL: :[[@LINE-1]]:7: warning: declaration 'OUTSIDER_1' is never referenced, but a declaration with the same name found in another namespace 'na'
+// CHECK-NOTES-ALL: note: a declaration of 'OUTSIDER_1' is found here
+} // namespace nb
+
+namespace na {
+template <typename T>
+class T_C;
+}
+
+namespace nb {
+// FIXME: this is an error, but we don't consider template class declaration
+// now.
+template <typename T>
+class T_C;
+} // namespace nb
+
+namespace na {
+template <typename T>
+class T_C {
+  int x;
+};
+} // namespace na
+
+namespace na {
+
+template <typename T>
+class T_TEMP {
+  template <typename _Tp1>
+  struct rebind { typedef T_TEMP<_Tp1> other; };
+};
+
+// We ignore class template specialization.
+template class T_TEMP<char>;
+} // namespace na
+
+namespace nb {
+
+template <typename T>
+class T_TEMP_1 {
+  template <typename _Tp1>
+  struct rebind { typedef T_TEMP_1<_Tp1> other; };
+};
+
+// We ignore class template specialization.
+extern template class T_TEMP_1<char>;
+} // namespace nb
+
+namespace nd {
+class D;
+// CHECK-NOTES-ALL: :[[@LINE-1]]:7: warning: declaration 'D' is never referenced, but a declaration with the same name found in another namespace 'nd::ne'
+// CHECK-NOTES-ALL: note: a declaration of 'D' is found here
+} // namespace nd
+
+namespace nd {
+namespace ne {
+class D;
+}
+} // namespace nd
+
+int f(nd::ne::D &d);
+
+// This should be ignored by the check.
+template <typename... Args>
+class Observer {
+  class Impl;
+};
+
+template <typename... Args>
+class Observer<Args...>::Impl {
+};
+
+// Work around limit of FileCheck, the expected warnings in a.h files are listed here.
+//
+// Warnings on namespace { class T_A; }
+// CHECK-NOTES-A: warning: declaration 'T_A' is never referenced, but a declaration with the same name found in another namespace 'na' [bugprone-forward-declaration-namespace]
+// CHECK-NOTES-A: note: a declaration of 'T_A' is found here
+// CHECK-NOTES-A1: warning: no definition found for 'T_A', but a definition with the same name 'T_A' found in another namespace '(global)' [bugprone-forward-declaration-namespace]
+// CHECK-NOTES-A1: note: a definition of 'T_A' is found here
+//
+// Warnings on namespace na { class T_A; }
+// CHECK-NOTES-A: warning: declaration 'T_A' is never referenced, but a declaration with the same name found in another namespace '(anonymous)'
+// CHECK-NOTES-A: note: a declaration of 'T_A' is found here
+// CHECK-NOTES-A1: warning: no definition found for 'T_A', but a definition with the same name 'T_A' found in another namespace '(global)'
+// CHECK-NOTES-A1: note: a definition of 'T_A' is found here

clang-tools-extra/test/clang-tidy/checkers/bugprone-forward-declaration-namespace.cpp

-// RUN: %check_clang_tidy %s bugprone-forward-declaration-namespace %t
+// RUN: %check_clang_tidy %s bugprone-forward-declaration-namespace %t -- --skip-headers=0
+// RUN: %check_clang_tidy %s bugprone-forward-declaration-namespace %t -- --skip-headers
 
 namespace {
 // This is a declaration in a wrong namespace.
 class T_A;
 // CHECK-NOTES: :[[@LINE-1]]:7: warning: declaration 'T_A' is never referenced, but a declaration with the same name found in another namespace 'na' [bugprone-forward-declaration-namespace]
 // CHECK-NOTES: note: a declaration of 'T_A' is found here
 // CHECK-NOTES: :[[@LINE-3]]:7: warning: no definition found for 'T_A', but a definition with the same name 'T_A' found in another namespace '(global)' [bugprone-forward-declaration-namespace]
 // CHECK-NOTES: note: a definition of 'T_A' is found here

clang-tools-extra/test/clang-tidy/checkers/bugprone-reserved-identifier.cpp

-// RUN: %check_clang_tidy %s bugprone-reserved-identifier %t -- -- \
+// RUN: %check_clang_tidy %s bugprone-reserved-identifier %t -- --skip-headers=0 -- \
+// RUN:   -I%S/Inputs/bugprone-reserved-identifier \
+// RUN:   -isystem %S/Inputs/bugprone-reserved-identifier/system
+// RUN: %check_clang_tidy %s bugprone-reserved-identifier %t -- --skip-headers -- \
 // RUN:   -I%S/Inputs/bugprone-reserved-identifier \
 // RUN:   -isystem %S/Inputs/bugprone-reserved-identifier/system
 
 // no warnings expected without -header-filter=
 #include "user-header.h"
 #include <system-header.h>
 
 #define _MACRO(m) int m = 0

clang-tools-extra/test/clang-tidy/checkers/bugprone-suspicious-include.cpp

-// RUN: %check_clang_tidy %s bugprone-suspicious-include %t -- -- -isystem %S/Inputs/Headers -fmodules
+// RUN: %check_clang_tidy %s bugprone-suspicious-include %t -- --skip-headers=0 -- -isystem %S/Inputs/Headers -fmodules
+// RUN: %check_clang_tidy %s bugprone-suspicious-include %t -- --skip-headers -- -isystem %S/Inputs/Headers -fmodules
 
 // clang-format off
 
 // CHECK-MESSAGES: [[@LINE+4]]:11: warning: suspicious #include of file with '.cpp' extension
 // CHECK-MESSAGES: [[@LINE+3]]:11: note: did you mean to include 'a'?
 // CHECK-MESSAGES: [[@LINE+2]]:11: note: did you mean to include 'a.h'?
 // CHECK-MESSAGES: [[@LINE+1]]:11: note: did you mean to include 'a.hpp'?
 #include "a.cpp"

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-interfaces-global-init.cpp

-// RUN: %check_clang_tidy %s cppcoreguidelines-interfaces-global-init %t
+// RUN: %check_clang_tidy %s cppcoreguidelines-interfaces-global-init %t -- --skip-headers=0
+// RUN: %check_clang_tidy %s cppcoreguidelines-interfaces-global-init %t -- --skip-headers
 
 constexpr int makesInt() { return 3; }
 constexpr int takesInt(int i) { return i + 1; }
 constexpr int takesIntPtr(int *i) { return *i; }
 
 extern int ExternGlobal;
 static int GlobalScopeBadInit1 = ExternGlobal;
 // CHECK-MESSAGES: [[@LINE-1]]:12: warning: initializing non-local variable with non-const expression depending on uninitialized non-local variable 'ExternGlobal'

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-macro-usage-command-line-macros.cpp

-// RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- -- -D_ZZZ_IM_A_MACRO
-// RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: true}]}' -- -D_ZZZ_IM_A_MACRO
-// RUN: %check_clang_tidy -check-suffixes=NORMAL,CL %s cppcoreguidelines-macro-usage %t -- -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: false}]}' -- -D_ZZZ_IM_A_MACRO
+// RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- --skip-headers=0 -- -D_ZZZ_IM_A_MACRO
+// RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- --skip-headers=0 -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: true}]}' -- -D_ZZZ_IM_A_MACRO
+// RUN: %check_clang_tidy -check-suffixes=NORMAL,CL %s cppcoreguidelines-macro-usage %t -- --skip-headers=0 -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: false}]}' -- -D_ZZZ_IM_A_MACRO
+//
+// Should work with --skip-header too.
+// RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- --skip-headers -- -D_ZZZ_IM_A_MACRO
+// RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- --skip-headers -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: true}]}' -- -D_ZZZ_IM_A_MACRO
+// RUN: %check_clang_tidy -check-suffixes=NORMAL,CL %s cppcoreguidelines-macro-usage %t -- --skip-headers -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: false}]}' -- -D_ZZZ_IM_A_MACRO
 
 // CHECK-MESSAGES-CL: warning: macro '_ZZZ_IM_A_MACRO' used to declare a constant; consider using a 'constexpr' constant
 
 #define PROBLEMATIC_CONSTANT 0
 // CHECK-MESSAGES-NORMAL: [[@LINE-1]]:9: warning: macro 'PROBLEMATIC_CONSTANT' used to declare a constant; consider using a 'constexpr' constant

clang-tools-extra/test/clang-tidy/checkers/google-namespaces.cpp

-// RUN: clang-tidy %s -checks='-*,google-build-namespaces,google-build-using-namespace' -header-filter='.*' -- | FileCheck %s -implicit-check-not="{{warning|error}}:"
+// RUN: clang-tidy %s --skip-headers=0 -checks='-*,google-build-namespaces,google-build-using-namespace' -header-filter='.*' -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK1 -implicit-check-not="{{warning|error}}:"
+
+// RUN: clang-tidy %s --skip-headers=0 -checks='-*,google-build-namespaces,google-build-using-namespace' -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK0 -implicit-check-not="{{warning|error}}:"
+//
+// RUN: clang-tidy %s --skip-headers -checks='-*,google-build-namespaces,google-build-using-namespace' -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK2 -implicit-check-not="{{warning|error}}:"
+//
+// -header-filter overrides --skip-header
+// RUN: clang-tidy %s --skip-headers -header-filter='.*' -checks='-*,google-build-namespaces,google-build-using-namespace' -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK1 -implicit-check-not="{{warning|error}}:"
+//
+// --show-all-warnings is like -header-filter=.* + -system-headers
+// RUN: clang-tidy %s --skip-headers=0 --show-all-warnings -checks='-*,google-build-namespaces,google-build-using-namespace' -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK1 -implicit-check-not="{{warning|error}}:"
+
+// --skip-header skips 1 warning in the header file.
+// CHECK0: 7 warnings generated
+// CHECK1: 7 warnings generated
+// CHECK2: 6 warnings generated
+
 #include "Inputs/google-namespaces.h"
-// CHECK: warning: do not use unnamed namespaces in header files [google-build-namespaces]
+// with -header-filter, warning in .h file is shown
+// CHECK1: warning: do not use unnamed namespaces in header files [google-build-namespaces]
+// without -header-filter, warning in .h files are not shown
+// CHECK0-NOT: warning: do not use unnamed namespaces in header files [google-build-namespaces]
+// with --skip-header, no warning in .h file is detected at all
+// CHECK2-NOT: warning: do not use unnamed namespaces in header files [google-build-namespaces]
 
 using namespace spaaaace;
 // CHECK: :[[@LINE-1]]:1: warning: do not use namespace using-directives; use using-declarations instead [google-build-using-namespace]
 
 using spaaaace::core; // no-warning
 
 namespace std {
 inline namespace literals {

 
 using namespace foo::literals::bar_literals;
 // CHECK: :[[@LINE-1]]:1: warning: do not use namespace using-directives; use using-declarations instead [google-build-using-namespace]
 
 namespace foo_literals {}
 
 using namespace foo_literals;
 // CHECK: :[[@LINE-1]]:1: warning: do not use namespace using-directives; use using-declarations instead [google-build-using-namespace]
+
+// If -header-filter= is not used and there is some warning in .h file,
+// give a reminder to use -header-filter.
+// CHECK0: Use -header-filter={{.*}} to display errors{{.*}}
+//
+// If -header-filter= is used, no summary of this message.
+// CHECK1-NOT: Use -header-filter={{.*}} to display errors{{.*}}
+//
+// With --skip-header, no warning in .h file is detected or hidden,
+// no need to give a reminder to use -header-filter.
+// CHECK2-NOT: Use -header-filter={{.*}} to display errors{{.*}}

clang-tools-extra/test/clang-tidy/checkers/google-objc-function-naming.m

-// RUN: %check_clang_tidy %s google-objc-function-naming %t -- -- -isystem %S/Inputs/Headers
+// RUN: %check_clang_tidy %s google-objc-function-naming %t -- --skip-headers=0 -- -isystem %S/Inputs/Headers
+// RUN: %check_clang_tidy %s google-objc-function-naming %t -- --skip-headers -- -isystem %S/Inputs/Headers
 
 #include <stdio.h>
 
 static void TestImplicitFunctionDeclaration(int a) {
   // Call a builtin function so that the compiler generates an implicit
   // function declaration.
   printf("%d", a);
 }

clang-tools-extra/test/clang-tidy/checkers/google-upgrade-googletest-case.cpp

-// RUN: %check_clang_tidy %s google-upgrade-googletest-case %t -- -- -I%S/Inputs
-// RUN: %check_clang_tidy -check-suffix=NOSUITE %s google-upgrade-googletest-case %t -- -- -DNOSUITE -I%S/Inputs/gtest/nosuite
+// RUN: %check_clang_tidy %s google-upgrade-googletest-case %t -- --skip-headers=0 -- -I%S/Inputs
+// RUN: %check_clang_tidy -check-suffix=NOSUITE %s google-upgrade-googletest-case %t -- --skip-headers=0 -- -DNOSUITE -I%S/Inputs/gtest/nosuite
+// RUN: %check_clang_tidy %s google-upgrade-googletest-case %t -- --skip-headers -- -I%S/Inputs
+// RUN: %check_clang_tidy -check-suffix=NOSUITE %s google-upgrade-googletest-case %t -- --skip-headers -- -DNOSUITE -I%S/Inputs/gtest/nosuite
 
 #include "gtest/gtest.h"
 
 // When including a version of googletest without the replacement names, this
 // check should not produce any diagnostics. The following dummy fix is present
 // because `check_clang_tidy.py` requires at least one warning, fix or note.
 void Dummy() {}
 // CHECK-FIXES-NOSUITE: void Dummy() {}

clang-tools-extra/test/clang-tidy/checkers/llvm-include-order.cpp

-// RUN: %check_clang_tidy %s llvm-include-order %t -- -- -isystem %S/Inputs/Headers
+// RUN: %check_clang_tidy %s llvm-include-order %t -- --skip-headers=0 -- -isystem %S/Inputs/Headers
+// RUN: %check_clang_tidy %s llvm-include-order %t -- --skip-headers -- -isystem %S/Inputs/Headers
 
 // CHECK-MESSAGES: [[@LINE+2]]:1: warning: #includes are not sorted properly
 #include "j.h"
 #include "gtest/foo.h"
 #include "gmock/foo.h"
 #include "i.h"
 #include <s.h>
 #include "llvm/a.h"

clang-tools-extra/test/clang-tidy/checkers/llvm-prefer-register-over-unsigned.cpp

-// RUN: %check_clang_tidy %s llvm-prefer-register-over-unsigned %t
+// RUN: %check_clang_tidy %s llvm-prefer-register-over-unsigned %t -- --skip-headers=0
+// RUN: %check_clang_tidy %s llvm-prefer-register-over-unsigned %t -- --skip-headers
 
 namespace llvm {
 class Register {
 public:
   operator unsigned();
 
   unsigned Reg;
 };

clang-tools-extra/test/clang-tidy/checkers/llvmlibc-implementation-in-namespace.cpp

-// RUN: %check_clang_tidy %s llvmlibc-implementation-in-namespace %t
+// RUN: %check_clang_tidy %s llvmlibc-implementation-in-namespace %t -- --skip-headers=0
+// RUN: %check_clang_tidy %s llvmlibc-implementation-in-namespace %t -- --skip-headers
 
 #define MACRO_A "defining macros outside namespace is valid"
 
 class ClassB;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: declaration must be declared within the '__llvm_libc' namespace
 struct StructC {};
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: declaration must be declared within the '__llvm_libc' namespace
 char *VarD = MACRO_A;

clang-tools-extra/test/clang-tidy/checkers/llvmlibc-restrict-system-libc-headers.cpp

 // RUN: %check_clang_tidy %s llvmlibc-restrict-system-libc-headers %t \
-// RUN:   -- -- -isystem %S/Inputs/llvmlibc/system \
+// RUN:   -- --skip-headers=0 -- -isystem %S/Inputs/llvmlibc/system \
+// RUN:   -resource-dir %S/Inputs/llvmlibc/resource
+//
+// RUN: %check_clang_tidy %s llvmlibc-restrict-system-libc-headers %t \
+// RUN:   -- --skip-headers -- -isystem %S/Inputs/llvmlibc/system \
 // RUN:   -resource-dir %S/Inputs/llvmlibc/resource
 
 #include <stdio.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include stdio.h not allowed
 #include <stdlib.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include stdlib.h not allowed
 #include "string.h"
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include string.h not allowed
 #include "stdatomic.h"
 #include <stddef.h>
 // Compiler provided headers should not throw warnings.

clang-tools-extra/test/clang-tidy/checkers/misc-no-recursion.cpp

-// RUN: %check_clang_tidy %s misc-no-recursion %t
+// RUN: %check_clang_tidy %s misc-no-recursion %t -- --skip-headers=0
+// RUN: %check_clang_tidy %s misc-no-recursion %t -- --skip-headers
 
 // We don't have the definition of this function,
 // so we can't tell anything about it..
 void external();
 
 // This function is obviously not recursive.
 void no_recursion() {
 }

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

-// RUN: %check_clang_tidy %s misc-unused-using-decls %t -- --fix-notes -- -fno-delayed-template-parsing -isystem %S/Inputs/
+// Setup header directory
+// RUN: rm -rf %theaders
+// RUN: mkdir %theaders
+// RUN: cp -R %S/Inputs/unused-using-decls.h %theaders
+
+// RUN: %check_clang_tidy %s misc-unused-using-decls %t -- --skip-headers=0 \
+// RUN:   --fix-notes -- -fno-delayed-template-parsing -I%theaders
+//
+// RUN: %check_clang_tidy %s misc-unused-using-decls %t -- --skip-headers \
+// RUN:   --fix-notes -- -fno-delayed-template-parsing -I%theaders
 
 // ----- Definitions -----
 template <typename T> class vector {};
 namespace n {
 class A;
 class B;
 class C;
 class D;

 enum Color2 { Red };
 
 enum Color3 { Yellow };
 
 enum Color4 { Blue };
 
 }  // namespace n
 
+namespace Q1 {
+class QC1;
+}
+using Q1::QC1;
+// Do not give warning about unused QC1!  It is used in .h file.
+// CHECK-MESSAGES-NOT: warning: using decl 'QC1' is unused
+
 #include "unused-using-decls.h"
+// FIXME: here we should have a warning on unused using decl 'QC2'
+
+namespace Q3 {
+class QC3;
+}
+using Q3::QC3; // QC3 should be removed
+// CHECK-MESSAGES: warning: using decl 'QC3' is unused
+// CHECK-MESSAGES: note: remove the using
+// CHECK-FIXES: {{^}}// QC3 should be removed
+
 namespace ns {
 template <typename T>
 class AA {
   T t;
 };
 template <typename T>
 T ff() { T t; return t; }
 } // namespace ns

clang-tools-extra/test/clang-tidy/checkers/modernize-deprecated-headers-cxx03.cpp

-// RUN: %check_clang_tidy -std=c++98 %s modernize-deprecated-headers %t -- -extra-arg-before=-isystem%S/Inputs/modernize-deprecated-headers
+// RUN: %check_clang_tidy -std=c++98 %s modernize-deprecated-headers %t -- --skip-headers=0 -extra-arg-before=-isystem%S/Inputs/modernize-deprecated-headers
+// RUN: %check_clang_tidy -std=c++98 %s modernize-deprecated-headers %t -- --skip-headers -extra-arg-before=-isystem%S/Inputs/modernize-deprecated-headers
 
 #include <assert.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'assert.h'; consider using 'cassert' instead [modernize-deprecated-headers]
 // CHECK-FIXES: {{^}}#include <cassert>{{$}}
 #include <complex.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'complex.h'; consider using 'complex' instead
 // CHECK-FIXES: {{^}}#include <complex>{{$}}
 #include <ctype.h>

clang-tools-extra/test/clang-tidy/checkers/modernize-deprecated-headers-cxx11.cpp

-// RUN: %check_clang_tidy -std=c++11-or-later %s modernize-deprecated-headers %t -- -extra-arg-before=-isystem%S/Inputs/modernize-deprecated-headers
+// RUN: %check_clang_tidy -std=c++11-or-later %s modernize-deprecated-headers %t -- --skip-headers=0 -extra-arg-before=-isystem%S/Inputs/modernize-deprecated-headers
+// RUN: %check_clang_tidy -std=c++11-or-later %s modernize-deprecated-headers %t -- --skip-headers -extra-arg-before=-isystem%S/Inputs/modernize-deprecated-headers
 
 #include <assert.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'assert.h'; consider using 'cassert' instead [modernize-deprecated-headers]
 // CHECK-FIXES: {{^}}#include <cassert>{{$}}
 #include <complex.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'complex.h'; consider using 'complex' instead
 // CHECK-FIXES: {{^}}#include <complex>{{$}}
 #include <ctype.h>

clang-tools-extra/test/clang-tidy/checkers/modernize-pass-by-value-header.cpp

+// Reuse some tests from modernize-pass-by-value.cpp,
+// to show that header file warnings can be skipped by skip-headers,
+// but fix to header files is already suppressed by -header-filter.
+//
+// (1) -fix --skip-headers=0, suppress warning and fix in .h file
+//          showmain,noheader fixmain, nofixheader
+// (2) -fix --skip-headers=1, skip warning and fix in .h file
+//          showmain,skipheader fixmain, nofixheader
+// (3) -fix --skip-headers=0 -header-filter=.* , show and fix warnings in .h file
+//          showmain,showheader fixmain, fixheader
+// (4) -fix --skip-headers=1 -header-filter=.* , show and fix warnings in .h file
+//          showmain,showheader fixmain, fixheader
+//
+// (1)
 // RUN: cp %S/Inputs/modernize-pass-by-value/header.h %T/pass-by-value-header.h
-// RUN: clang-tidy %s -checks='-*,modernize-pass-by-value' -header-filter='.*' -fix -- -std=c++11 -I %T | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not="{{warning|error}}:"
-// RUN: FileCheck -input-file=%T/pass-by-value-header.h %s -check-prefix=CHECK-FIXES
-// FIXME: Make the test work in all language modes.
+// RUN: cp %S/modernize-pass-by-value-header.cpp %T/pass-by-value-header.cpp
+// RUN: clang-tidy %T/pass-by-value-header.cpp -checks='-*,modernize-pass-by-value' \
+// RUN: --skip-headers=0 -fix -- -std=c++11 2>&1 \
+// RUN: | FileCheck %s -check-prefixes=SHOWMAIN,NOHEADER
+// RUN: FileCheck -input-file=%T/pass-by-value-header.h %s -check-prefix=NOFIXHEADER
+// RUN: FileCheck -input-file=%T/pass-by-value-header.cpp %s -check-prefix=FIXMAIN
+//
+// (2)
+// RUN: cp %S/Inputs/modernize-pass-by-value/header.h %T/pass-by-value-header.h
+// RUN: cp %S/modernize-pass-by-value-header.cpp %T/pass-by-value-header.cpp
+// RUN: clang-tidy %T/pass-by-value-header.cpp -checks='-*,modernize-pass-by-value' \
+// RUN: --skip-headers -fix -- -std=c++11 2>&1 \
+// RUN: | FileCheck %s -check-prefixes=SHOWMAIN,SKIPHEADER
+// RUN: FileCheck -input-file=%T/pass-by-value-header.h %s -check-prefix=NOFIXHEADER
+// RUN: FileCheck -input-file=%T/pass-by-value-header.cpp %s -check-prefix=FIXMAIN
+//
+// (3)
+// RUN: cp %S/Inputs/modernize-pass-by-value/header.h %T/pass-by-value-header.h
+// RUN: cp %S/modernize-pass-by-value-header.cpp %T/pass-by-value-header.cpp
+// RUN: clang-tidy %T/pass-by-value-header.cpp -checks='-*,modernize-pass-by-value' \
+// RUN: --header-filter=.* --skip-headers=0 -fix -- -std=c++11 2>&1 \
+// RUN: | FileCheck %s -check-prefixes=SHOWMAIN,SHOWHEADER
+// RUN: FileCheck -input-file=%T/pass-by-value-header.h %s -check-prefix=FIXHEADER
+// RUN: FileCheck -input-file=%T/pass-by-value-header.cpp %s -check-prefix=FIXMAIN
+//
+// (4)
+// RUN: cp %S/Inputs/modernize-pass-by-value/header.h %T/pass-by-value-header.h
+// RUN: cp %S/modernize-pass-by-value-header.cpp %T/pass-by-value-header.cpp
+// RUN: clang-tidy %T/pass-by-value-header.cpp -checks='-*,modernize-pass-by-value' \
+// RUN: --header-filter=.* --skip-headers -fix -- -std=c++11 2>&1 \
+// RUN: | FileCheck %s -check-prefixes=SHOWMAIN,SHOWHEADER
+// RUN: FileCheck -input-file=%T/pass-by-value-header.h %s -check-prefix=FIXHEADER
+// RUN: FileCheck -input-file=%T/pass-by-value-header.cpp %s -check-prefix=FIXMAIN
 
 #include "pass-by-value-header.h"
-// CHECK-MESSAGES: :8:5: warning: pass by value and use std::move [modernize-pass-by-value]
-// CHECK-FIXES: #include <utility>
-// CHECK-FIXES: A(ThreadId tid) : threadid(std::move(tid)) {}
+// FIXHEADER: #include <utility>
+// FIXHEADER: struct A
+// FIXHEADER: A(ThreadId tid) : threadid(std::move(tid)) {}
+// NOFIXHEADER-NOT: #include <utility>
+// NOFIXHEADER: struct A
+// NOFIXHEADER: A(const ThreadId &tid) : threadid(tid) {}
+// NOFIXHEADER-NOT: A(ThreadId tid) : threadid(std::move(tid)) {}
+
+// Test that both declaration and definition are updated.
+struct D {
+  D(const Movable &M);
+  // FIXMAIN: D(Movable M);
+  Movable M;
+};
+// NOTE! Use DAG tage because header file warnings may shown after
+// main file warnings on Linux,  but before main file warnings on Windows.
+// SHOWHEADER-DAG: :8:5: warning: pass by value and use std::move [modernize-pass-by-value]
+// NOHEADER-NOT:   :8:5: warning: pass by value and use std::move [modernize-pass-by-value]
+// SKIPHEADER-NOT: :8:5: warning: pass by value and use std::move [modernize-pass-by-value]
+
+D::D(const Movable &M) : M(M) {}
+// SHOWMAIN-DAG: :[[@LINE-1]]:6: warning: pass by value and use std::move
+// FIXMAIN: D::D(Movable M) : M(std::move(M)) {}
+
+// no more warning or error
+// SHOWMAIN-NOT:   {{warning|error}}:
+// SHOWHEADER-NOT: {{warning|error}}:
+// NOHEADER-NOT:   {{warning|error}}:
+// SKIPHEADER-NOT: {{warning|error}}:
+//
+// NOHEADER: Suppressed {{.*}} warnings
+// SKIPHEADER-NOT: Suppressed {{.*}} warnings
+// SHOWHEADER-NOT: Suppressed {{.*}} warnings

clang-tools-extra/test/clang-tidy/checkers/portability-restrict-system-includes-allow.cpp

 // RUN: %check_clang_tidy %s portability-restrict-system-includes %t \
-// RUN:     -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: '*,-stddef.h'}]}" \
+// RUN:     -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: '*,-stddef.h'}]}" --skip-headers=0 \
+// RUN:     -- -isystem %S/Inputs/portability-restrict-system-includes/system
+//
+// RUN: %check_clang_tidy %s portability-restrict-system-includes %t \
+// RUN:     -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: '*,-stddef.h'}]}" --skip-headers \
 // RUN:     -- -isystem %S/Inputs/portability-restrict-system-includes/system
 
 // Test block-list functionality: allow all but stddef.h.
 
 #include <stddef.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include stddef.h not allowed
 #include <stdint.h>
 #include <float.h>

clang-tools-extra/test/clang-tidy/checkers/portability-restrict-system-includes-disallow.cpp

 // RUN: %check_clang_tidy %s portability-restrict-system-includes %t \
-// RUN:     -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: '-*,stddef.h'}]}" \
+// RUN:     -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: '-*,stddef.h'}]}" --skip-headers=0 \
+// RUN:     -- -isystem %S/Inputs/portability-restrict-system-includes/system
+//
+// RUN: %check_clang_tidy %s portability-restrict-system-includes %t \
+// RUN:     -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: '-*,stddef.h'}]}" --skip-headers \
 // RUN:     -- -isystem %S/Inputs/portability-restrict-system-includes/system
 
 // Test allow-list functionality: disallow all but stddef.h.
 
 #include <stddef.h>
 #include <stdint.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include stdint.h not allowed
 #include <float.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include float.h not allowed

clang-tools-extra/test/clang-tidy/checkers/readability-simplify-bool-expr-chained-conditional-assignment.cpp

-// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalAssignment", value: true}]}" --
+// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- --skip-headers=0 \
+// RUN: -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalAssignment", value: true}]}" --
+// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- --skip-headers \
+// RUN: -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalAssignment", value: true}]}" --
 
 void chained_conditional_compound_assignment(int i) {
   bool b;
   if (i < 0) {
     b = true;
   } else if (i < 10) {
     b = false;
   } else if (i > 20) {

clang-tools-extra/test/clang-tidy/checkers/readability-simplify-bool-expr-chained-conditional-return.cpp

-// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalReturn", value: true}]}" --
+// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- --skip-headers=0 \
+// RUN: -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalReturn", value: true}]}" --
+// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- --skip-headers \
+// RUN: -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalReturn", value: true}]}" --
 
 bool chained_conditional_compound_return(int i) {
   if (i < 0) {
     return true;
   } else if (i < 10) {
     return false;
   } else if (i > 20) {
     return true;

clang-tools-extra/test/clang-tidy/checkers/readability-simplify-bool-expr-members.cpp

-// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t
+// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- --skip-headers=0
+// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- --skip-headers
 
 class A {
 public:
   int m;
 };
 
 struct S {
   S() : m_ar(s_a) {}

clang-tools-extra/test/clang-tidy/checkers/readability-simplify-bool-expr.cpp

-// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t
+// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- --skip-headers=0
+// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- --skip-headers
 
 bool a1 = false;
 
 //=-=-=-=-=-=-= operator ==
 bool aa = false == a1;
 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant boolean literal supplied to boolean operator [readability-simplify-boolean-expr]
 // CHECK-FIXES: {{^bool aa = !a1;$}}
 bool ab = true == a1;

clang-tools-extra/test/clang-tidy/checkers/skip-headers-1.cpp

+// Test --skip-headers, --show-all-warnings, and --header-filter.
+//
+// Default shows no warning in .h files, with hint to use --header-filter
+// RUN: clang-tidy %s -checks='*' --skip-headers=0 -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes COUNTER,NOHEADER,MAIN,HINT
+//
+// --skip-headers skips all included files warnings; without hint
+// RUN: clang-tidy %s -checks='*' --skip-headers -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes COUNTER,NOHEADER,MAIN,NOHINT
+//
+// --show-all-warnings reports all warnings, even without --header-filters
+// RUN: clang-tidy %s -checks='*' --show-all-warnings --skip-headers=0 -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes COUNTER,HEADER,MAIN,NOHINT
+//
+// --header-filter='.*' is like --show-all-warnings
+// RUN: clang-tidy %s -checks='*' --header-filter='.*' --skip-headers=0 -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes COUNTER,HEADER,MAIN,NOHINT
+//
+// With --show-all-warnings and --skip-headers,
+// no warnings should be reported from header files.
+// RUN: clang-tidy %s -checks='*' --skip-headers --show-all-warnings -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes COUNTER,NOHEADER,MAIN,NOHINT
+//
+// --header-filter='header1.h' shows only warnings in header1.h
+// RUN: clang-tidy %s -checks='*' --header-filter='header1.h' --skip-headers=0 -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes COUNTER,H1,MAIN,HINT
+//
+// RUN: clang-tidy %s -checks='*' --header-filter='header1.h' --skip-headers -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes COUNTER,H1,MAIN,NOHINT
+//
+// --header-filter='header2.h' shows only warnings in header2.h
+// RUN: clang-tidy %s -checks='*' --header-filter='header2.h' --skip-headers=0 -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes COUNTER,H2,MAIN,HINT
+//
+// RUN: clang-tidy %s -checks='*' --header-filter='header2.h' --skip-headers -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes COUNTER,H2,MAIN,NOHINT
+
+// All options have warning count reported:
+// COUNTER: {{[0-9]+}} warnings generated.
+
+// Not all PPCallback checks have supported skip-header yet.
+// So, some headers still have warnings.
+#include "Inputs/skip-headers/my_header1.h"
+// H1: my_header1.h:1:1: warning: header is missing header guard
+// HEADER: my_header1.h:1:1: warning: header is missing header guard
+// H2-NOT: my_header1.h
+// NOHEADER-NOT: my_header1.h FIXME
+
+// H2: my_header2.h:1:1: warning: header is missing header guard
+// HEADER: my_header2.h:1:1: warning: header is missing header guard
+// H1-NOT: my_header2.h
+// NOHEADER-NOT: my_header2.h FIXME
+
+int xyz = 135;
+// MAIN: skip-headers-1.cpp:{{[0-9]+}}:{{[0-9]+}}: warning:
+
+// HINT: Use -header-filter={{.*}} to display errors{{.*}}
+// NOHINT-NOT: Use -header-filter= FIXME
+// Not all PPCallback checks have supported skip-header yet.
+// So there are still "hint" at the end of these tests.

clang-tools-extra/test/clang-tidy/checkers/skip-headers-2.cpp

+// Test --skip-headers, --show-all-warnings, and --header-filter
+// with nested Decls. Users should be able to select exactly
+// which .h file to check for warnings.
+// Here a.h includes/uses b.h. Maintainers of a.h wants to check/see
+// warnings in a.h but not b.h. So they use --header-filer=a.h --skip-headers.
+//
+// RUN: clang-tidy %s --skip-headers=0 --show-all-warnings \
+// RUN: -checks='-*,readability-convert-member-functions-to-static' -- \
+// RUN: | FileCheck %s -check-prefixes WARNA,WARNB,WARNMAIN
+//
+// RUN: clang-tidy %s --skip-headers=1 --show-all-warnings \
+// RUN: -checks='-*,readability-convert-member-functions-to-static' -- \
+// RUN: | FileCheck %s -check-prefixes WARNMAIN,NOWARNA,NOWARNB
+//
+// RUN: clang-tidy %s --skip-headers=1 --show-all-warnings --header-filter=a.h \
+// RUN: -checks='-*,readability-convert-member-functions-to-static' -- \
+// RUN: | FileCheck %s -check-prefixes WARNMAIN,WARNA,NOWARNB
+//
+// RUN: clang-tidy %s --skip-headers=1 --show-all-warnings --header-filter=.* \
+// RUN: -checks='-*,readability-convert-member-functions-to-static' -- \
+// RUN: | FileCheck %s -check-prefixes WARNMAIN,WARNA,WARNB
+//
+// Current limitation of --skip-haders: b.h is skipped if a.h is skipped.
+// RUN: clang-tidy %s --skip-headers=1 --show-all-warnings --header-filter=b.h \
+// RUN: -checks='-*,readability-convert-member-functions-to-static' -- \
+// RUN: | FileCheck %s -check-prefixes WARNMAIN,NOWARNA,NOWARNB
+
+#include "Inputs/skip-headers/a.h"
+
+// WARNA: warning: method 'fooA' can be made static
+// NOWARNA-NOT: warning: method 'fooA' can be made static
+
+// WARNB: warning: method 'fooB' can be made static
+// NOWARNB-NOT: warning: method 'fooB' can be made static
+
+class C {
+  void foo(int x) { x = 3; };
+  // WARNMAIN: warning: method 'foo' can be made static
+};

clang-tools-extra/test/clang-tidy/checkers/skip-headers-3.cpp

+// Test --skip-headers, which should skip statements and expressions
+// in a called function of header files even if the calling function
+// is in the main file.
+//
+// RUN: clang-tidy %s --skip-headers=0 --show-all-warnings \
+// RUN: -checks='-*,cert-dcl16-c' \
+// RUN: | FileCheck %s -check-prefixes WARNC,MAIN
+//
+// RUN: clang-tidy %s --skip-headers --show-all-warnings \
+// RUN: -checks='-*,cert-dcl16-c' --header-filter=c1.h \
+// RUN: | FileCheck %s -check-prefixes MAIN,WARNC
+//
+// RUN: clang-tidy %s --skip-headers --show-all-warnings \
+// RUN: -checks='-*,cert-dcl16-c' \
+// RUN: | FileCheck %s -check-prefixes MAIN,NOWARNC
+
+#include "Inputs/skip-headers/c1.h"
+// WARNC: c1.h:5:27: warning: integer literal has suffix 'll', which is not uppercase [cert-dcl16-c]
+// WARNC: c1.h:6:20: warning: integer literal has suffix 'll', which is not uppercase [cert-dcl16-c]
+// NOWARNC-NOT: c1.h:5:27: warning: integer literal has suffix 'll', which is not uppercase [cert-dcl16-c]
+// NOWARNC-NOT: c1.h:6:20: warning: integer literal has suffix 'll', which is not uppercase [cert-dcl16-c]
+
+void foo(int x = 3ll, C1 *p = nullptr) {
+  // MAIN: skip-headers-3.cpp:[[@LINE-1]]:18: warning: integer literal has suffix 'll', which is not uppercase [cert-dcl16-c]
+  C1::foo1();
+  p->foo2();
+  p->foo3(x);
+}
+
+// MAIN-NOT: warning: integer literal has suffix 'll', which is not uppercase [cert-dcl16-c]

clang-tools-extra/test/clang-tidy/checkers/skip-headers-4.cpp

+// When the statement of a template function call does not have a
+// "valid" source location and its default argument value cast expression
+// is in an included header file, the warning on the expression should
+// be suppressed by --skip-headers.
+//
+// RUN: clang-tidy %s --skip-headers=0 \
+// RUN: -checks='-*,modernize-use-nullptr' -- \
+// RUN: | FileCheck %s -check-prefixes MAIN,NOWARNC
+//
+// RUN: clang-tidy %s --skip-headers --show-all-warnings \
+// RUN: -checks='-*,modernize-use-nullptr' -- \
+// RUN: | FileCheck %s -check-prefixes MAIN,NOWARNC
+//
+// RUN: clang-tidy %s --skip-headers=0 \
+// RUN: -checks='-*,modernize-use-nullptr' -header-filter=c.h -- \
+// RUN: | FileCheck %s -check-prefixes MAIN,WARNC
+//
+// RUN: clang-tidy %s --skip-headers --show-all-warnings \
+// RUN: -checks='-*,modernize-use-nullptr' -header-filter=c.h -- \
+// RUN: | FileCheck %s -check-prefixes MAIN,WARNC
+
+#include "Inputs/skip-headers/c.h"
+// WARNC: c.h:5:34: warning: use nullptr [modernize-use-nullptr]
+// NOWARNC-NOT: c.h:5:34: warning: use nullptr [modernize-use-nullptr]
+// NOWARNC-NOT: c.h:
+
+template <class T>
+class D {
+public:
+  template <class R>
+  explicit D(const R r, int *x = 0) : p(x) {}
+  // MAIN: :[[@LINE-1]]:34: warning: use nullptr [modernize-use-nullptr]
+private:
+  int *p;
+};
+
+C<int> x = C<int>(2);
+D<int> y = D<int>(4);
+
+// MAIN-NOT: warning:

clang-tools-extra/test/clang-tidy/infrastructure/file-filter-symlinks.cpp

 // REQUIRES: shell
 
 // RUN: rm -rf %t
 // RUN: mkdir -p %t/dir1/dir2
 // RUN: echo 'class A { A(int); };' > %t/dir1/header.h
 // RUN: ln -s %t/dir1/header.h %t/dir1/header_alias.h
 //
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='dir1/dir2/\.\./header_alias\.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='dir1/dir2/\.\./header_alias\.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header_alias\.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header_alias\.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header\.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header\.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='dir1/dir2/\.\./header_alias\.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='dir1/dir2/\.\./header_alias\.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='header_alias\.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='header_alias\.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER_ALIAS %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='header\.h' %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='header\.h' -quiet %s -- -I %t 2>&1 | FileCheck --check-prefix=CHECK_HEADER %s
 
 // Check that `-header-filter` operates on the same file paths as paths in
 // diagnostics printed by ClangTidy.
 #include "dir1/dir2/../header_alias.h"
 // CHECK_HEADER_ALIAS: dir1/dir2/../header_alias.h:1:11: warning: single-argument constructors
 // CHECK_HEADER-NOT: warning:

clang-tools-extra/test/clang-tidy/infrastructure/file-filter.cpp

-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK-QUIET %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK2 %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK2-QUIET %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header2\.h' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK3 %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header2\.h' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK3-QUIET %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK-QUIET %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='.*' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK2 %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='.*' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK2-QUIET %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='header2\.h' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK3 %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='header2\.h' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK3-QUIET %s
 // FIXME: "-I %S/Inputs/file-filter/system/.." must be redundant.
 //       On Win32, file-filter/system\system-header1.h precedes
 //       file-filter\header*.h due to code order between '/' and '\\'.
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' -system-headers %s -- -I %S/Inputs/file-filter/system/.. -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK4 %s
-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' -system-headers -quiet %s -- -I %S/Inputs/file-filter/system/.. -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK4-QUIET %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='.*' -system-headers %s -- -I %S/Inputs/file-filter/system/.. -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK4 %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -header-filter='.*' -system-headers -quiet %s -- -I %S/Inputs/file-filter/system/.. -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK4-QUIET %s
 
 #include "header1.h"
 // CHECK-NOT: warning:
 // CHECK-QUIET-NOT: warning:
 // CHECK2: header1.h:1:12: warning: single-argument constructors must be marked explicit
 // CHECK2-QUIET: header1.h:1:12: warning: single-argument constructors must be marked explicit
 // CHECK3-NOT: warning:
 // CHECK3-QUIET-NOT: warning:

clang-tools-extra/test/clang-tidy/infrastructure/line-filter.cpp

-// RUN: clang-tidy -checks='-*,google-explicit-constructor' -line-filter='[{"name":"line-filter.cpp","lines":[[18,18],[22,22]]},{"name":"header1.h","lines":[[1,2]]},{"name":"header2.h"},{"name":"header3.h"}]' -header-filter='header[12]\.h$' %s -- -I %S/Inputs/line-filter 2>&1 | FileCheck %s
+// RUN: clang-tidy --skip-headers=0 -checks='-*,google-explicit-constructor' -line-filter='[{"name":"line-filter.cpp","lines":[[18,18],[22,22]]},{"name":"header1.h","lines":[[1,2]]},{"name":"header2.h"},{"name":"header3.h"}]' -header-filter='header[12]\.h$' %s -- -I %S/Inputs/line-filter 2>&1 | FileCheck %s
 
 #include "header1.h"
 // CHECK-NOT: header1.h:{{.*}} warning
 // CHECK: header1.h:1:12: warning: single-argument constructors must be marked explicit
 // CHECK: header1.h:2:12: warning: single-argument constructors {{.*}}
 // CHECK-NOT: header1.h:{{.*}} warning
 
 #include "header2.h"

clang/include/clang/ASTMatchers/ASTMatchFinder.h

public:
   struct MatchFinderOptions {
     struct Profiling {
       Profiling(llvm::StringMap<llvm::TimeRecord> &Records)
           : Records(Records) {}
 
       /// Per bucket timing information.
       llvm::StringMap<llvm::TimeRecord> &Records;
     };
+    struct LocFilter {
+      virtual bool skipLocation(SourceLocation) const = 0;
+      virtual ~LocFilter();
+    };
 
     /// Enables per-check timers.
     ///
     /// It prints a report after match.
     llvm::Optional<Profiling> CheckProfiling;
+
+    /// Check if MatchASTVisitor should skip node at a location.
+    std::shared_ptr<LocFilter> Filter;
   };
 
   MatchFinder(MatchFinderOptions Options = MatchFinderOptions());
   ~MatchFinder();
 
   /// Adds a matcher to execute when running over the AST.
   ///
   /// Calls 'Action' with the BoundNodes on every match.

clang/include/clang/Frontend/MultiplexConsumer.h

public:
   ASTDeserializationListener *GetASTDeserializationListener() override;
   void PrintStats() override;
   bool shouldSkipFunctionBody(Decl *D) override;
 
   // SemaConsumer
   void InitializeSema(Sema &S) override;
   void ForgetSema() override;
 
-private:
+protected:
   std::vector<std::unique_ptr<ASTConsumer>> Consumers; // Owns these.
+private:
   std::unique_ptr<MultiplexASTMutationListener> MutationListener;
   std::unique_ptr<MultiplexASTDeserializationListener> DeserializationListener;
 };
 
 }  // end namespace clang
 
 #endif

clang/lib/ASTMatchers/ASTMatchFinder.cpp

bool MatchASTVisitor::objcClassIsDerivedFrom(
 
   return false;
 }
 
 bool MatchASTVisitor::TraverseDecl(Decl *DeclNode) {
   if (!DeclNode) {
     return true;
   }
+  if (Options.Filter && Options.Filter->skipLocation(DeclNode->getLocation()))
+    return true;
 
   bool ScopedTraversal =
       TraversingASTNodeNotSpelledInSource || DeclNode->isImplicit();
   bool ScopedChildren = TraversingASTChildrenNotSpelledInSource;
 
   if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(DeclNode)) {
     auto SK = CTSD->getSpecializationKind();
     if (SK == TSK_ExplicitInstantiationDeclaration ||
bool MatchASTVisitor::TraverseDecl(Decl *DeclNode) {
   match(*DeclNode);
   return RecursiveASTVisitor<MatchASTVisitor>::TraverseDecl(DeclNode);
 }
 
 bool MatchASTVisitor::TraverseStmt(Stmt *StmtNode, DataRecursionQueue *Queue) {
   if (!StmtNode) {
     return true;
   }
+  // When a function call is in the main file or wanted header files,
+  // the call site maybe in the Decl that is not to be skipped.
+  // But the statements of the called function or parameter default expressions
+  // should be skipped. So here we need to call skipLocation here.
+  if (Options.Filter && Options.Filter->skipLocation(StmtNode->getBeginLoc()))
+    return true;
+
   bool ScopedTraversal = TraversingASTNodeNotSpelledInSource ||
                          TraversingASTChildrenNotSpelledInSource;
 
   ASTNodeNotSpelledInSourceScope RAII(this, ScopedTraversal);
   match(*StmtNode);
   return RecursiveASTVisitor<MatchASTVisitor>::TraverseStmt(StmtNode, Queue);
 }
 

 
 StringRef MatchFinder::MatchCallback::getID() const { return "<unknown>"; }
 
 llvm::Optional<TraversalKind>
 MatchFinder::MatchCallback::getCheckTraversalKind() const {
   return llvm::None;
 }
 
+MatchFinder::MatchFinderOptions::LocFilter::~LocFilter() = default;
+
 } // end namespace ast_matchers
 } // end namespace clang