[clang-tidy] New feature --skip-headers, part 1, LocationFilter

[chh]

Summary

[clang-tidy] New feature --skip-headers, LocationFilter

• 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.
• 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]

hide the --show-all-warnings flag from --help

[chh]

sync with latest clang/llvm

[chh]

sync with latest source, update more tests to test skip-headers as default

[chh]

only coding style changes in clang-tidy files, to match other alternative implementation

[chh]

--skip-headers is set to false by default;
many tidy tests runs are augmented with explicit --skip-headers or --skip-headers=0
to test this feature as on or off.

[chh]

Add bugprone-forward-declaration-namespace-header.cpp test; fix some coding style warnings.

[chh]

Add one more skip-headers-2.cpp test.

[chh]

Add an AllFileFinder for checks that need to match all source files.
ForwardDeclarationNamespaceCheck is registered as an AllFileCheck,

[chh]

add skip-headers-3.cpp test to show that checking only Decl locations is not enough to skip some warnings in header files

[chh]

• Use clang-format layout in ClangTidy.cpp and ClangTidyModule.h.
• Fix misc-unused-using-decls false-positive warning from --skip-headers.
  • UnusedUsingDeclsCheck is now registered as an AllFileCheck.
  • Add new test cases into misc-unused-using-decls.cpp.

[chh]

apply clang-format

[chh]

sync to the latest source; apply clang-format; add new skip-headers-4.cpp test;
skip modernize-use-nullptr warnings in header files in UseNullptrCheck.cpp

[chh]

This is enhanced implementation over D98710, to handle the new found failed test cases.

[chh]

Factor out LocationFilter; improve more test cases.

[chh]

fix windows test failure

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

private:
   llvm::StringMap<Replacements> FileReplacements;
   ClangTidyContext &Context;
   FixBehaviour ApplyFixes;
   unsigned TotalFixes;
   unsigned AppliedFixes;
   unsigned WarningsAsErrors;
 };
 
+using OptionsLocFilter =
+    ast_matchers::MatchFinder::MatchFinderOptions::LocFilter;
+
+// Check if a Location should be skipped by clang-tidy checks.
+struct LocFilter : OptionsLocFilter {
+  LocFilter(ClangTidyContext &Ctx, SourceManager &SM)
+      : Context(Ctx), Sources(SM) {
+    HeaderFilter =
+        std::make_unique<llvm::Regex>(*Ctx.getOptions().HeaderFilterRegex);
+    LastSkippedFileID = FileID::getSentinel();
+    LastAcceptedFileID = FileID::getSentinel();
+  }
+  bool skipLocation(SourceLocation) override;
+
+private:
+  bool skipFileID(SourceLocation, FileID);
+  ClangTidyContext &Context;
+  SourceManager &Sources;
+  std::unique_ptr<llvm::Regex> HeaderFilter;
+  FileID LastSkippedFileID;
+  FileID LastAcceptedFileID;
+};
+
+bool LocFilter::skipFileID(SourceLocation Location, FileID FID) {
+  // do not skip the main file
+  if (Sources.isInMainFile(Location))
+    return false;
+  // skip system headers unless --system-headers is used
+  if (Sources.isInSystemHeader(Location))
+    return !*Context.getOptions().SystemHeaders;
+  const FileEntry *File = Sources.getFileEntryForID(FID);
+  // without a FileEntry, cannot verify header file path to skip
+  if (!File)
+    return false;
+  StringRef FileName(File->getName());
+  // skip, unless file name matches --header-filter
+  return !HeaderFilter->match(FileName);
+}
+
+bool LocFilter::skipLocation(SourceLocation Location) {
+  // cannot get valid FileID if Location is invalid
+  if (!Location.isValid())
+    return false;
+  // Similar to ClangTidyDiagnosticConsumer::checkFilters,
+  // the decision to skip a check depends on getDecomposedExpansionLoc.
+  auto FID = Sources.getDecomposedExpansionLoc(Location).first;
+  // Quick check against last checked results.
+  if (FID == LastSkippedFileID)
+    return true;
+  if (FID == LastAcceptedFileID)
+    return false;
+  auto ShouldSkip = skipFileID(Location, FID);
+  if (ShouldSkip) {
+    LastSkippedFileID = FID;
+  } else {
+    LastAcceptedFileID = FID;
+  }
+  return ShouldSkip;
+}
+
 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)
+                       std::unique_ptr<ast_matchers::MatchFinder> AllFileFinder,
+                       std::vector<std::unique_ptr<ClangTidyCheck>> Checks,
+                       std::vector<std::unique_ptr<ClangTidyCheck>> AllFileChecks)
       : 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)) {}
 
 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;
 };
 
 } // namespace
 
 ClangTidyASTConsumerFactory::ClangTidyASTConsumerFactory(
     ClangTidyContext &Context,
     IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFS)
     : Context(Context), OverlayFS(std::move(OverlayFS)),
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);
   }
 
+  // SharedLocFilter is not for AllFileFinder.
+  std::shared_ptr<OptionsLocFilter> SharedLocFilter;
+  if (*Context.getOptions().SkipHeaders)
+    SharedLocFilter =
+        std::shared_ptr<OptionsLocFilter>(new LocFilter(Context, *SM));
+  FinderOptions.Filter = SharedLocFilter;
+  ClangTidyCheck::Filter = SharedLocFilter;
+
   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());
+  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
   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));
 }
 
 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:
   };
 
 private:
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
   StringRef getID() const override { return CheckName; }
   std::string CheckName;
   ClangTidyContext *Context;
 
+  typedef ast_matchers::MatchFinder::MatchFinderOptions::LocFilter FilterType;
+  static std::shared_ptr<FilterType> Filter;
+  friend class ClangTidyASTConsumerFactory; // sets Filter
+
 protected:
   OptionsView Options;
   /// Returns the main file name of the current translation unit.
   StringRef getCurrentMainFile() const { return Context->getCurrentFile(); }
   /// Returns the language options from the context.
   const LangOptions &getLangOpts() const { return Context->getLangOpts(); }
+  /// Returns true if skip-headers needs to skip the given Loc.
+  static bool skipLocation(SourceLocation Loc) {
+    return Filter && Filter->skipLocation(Loc);
+  }
 };
 
 /// Read a named option from the ``Context`` and parse it as a bool.
 ///
 /// Reads the option with the check-local name \p LocalName from the
 /// ``CheckOptions``. If the corresponding key is not present, return
 /// ``None``.
 ///

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

 }
 std::string
 ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName,
                                               StringRef Default) const {
   if (llvm::Optional<std::string> Val = getLocalOrGlobal(LocalName))
     return std::move(*Val);
   return Default.str();
 }
+
+std::shared_ptr<ClangTidyCheck::FilterType> ClangTidyCheck::Filter;
+
 } // namespace tidy
 } // namespace clang

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

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;

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) {
+  template <typename CheckType> void registerCheck(llvm::StringRef CheckName,
+                                                   bool IsAllFileCheck = false) {
     registerCheckFactory(CheckName,
                          [](llvm::StringRef Name, ClangTidyContext *Context) {
                            return std::make_unique<CheckType>(Name, Context);
-                         });
+                         }, 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/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 na {
+// This is a declaration in a wrong namespace.
+class T_A;
+}

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;
+};
+}

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/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/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
 
 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 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
+}
+
+#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
+}
+
+// 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;
+}
+
+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 nd {
+class OUTSIDER_1;
+void f(OUTSIDER_1 *);
+}
+
+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 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 na {
+template<typename T>
+class T_C {
+  int x;
+};
+}
+
+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 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 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 ne {
+class D;
+}
+}
+
+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/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/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/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

 // 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: clang-tidy %s -checks='-*,modernize-pass-by-value' -header-filter='.*' -fix -- -std=c++11 -I %T \
+// RUN: | 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
+//
+// RUN: cp %S/Inputs/modernize-pass-by-value/header.h %T/pass-by-value-header.h
+// RUN: clang-tidy %s -checks='*' --skip-headers=0 -- -std=c++11 -I %T \
+// RUN: 2>&1 | FileCheck %s -check-prefix=CHECK-NOHEADER -allow-empty
+//
+// 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' --skip-headers -fix -- -std=c++11 -I %T \
+// RUN: | FileCheck %s -check-prefix=CHECK-SKIP -allow-empty -implicit-check-not="{{warning|error}}:"
+// RUN: FileCheck -input-file=%T/pass-by-value-header.h %s -check-prefix=CHECK-SKIP-FIXES
+//
+// RUN: cp %S/Inputs/modernize-pass-by-value/header.h %T/pass-by-value-header.h
+// RUN: clang-tidy %s -checks='*' --skip-headers -- -std=c++11 -I %T \
+// RUN: | FileCheck %s -check-prefix=CHECK-SKIP -allow-empty -implicit-check-not="{{warning|error}}:"
+//
 // FIXME: Make the test work in all language modes.
 
 #include "pass-by-value-header.h"
-// CHECK-MESSAGES: :8:5: warning: pass by value and use std::move [modernize-pass-by-value]
+// header file warnings are not shown, with --skip-headers, or without -header-filter
+// CHECK-MESSAGES:     :8:5: warning: pass by value and use std::move [modernize-pass-by-value]
+// CHECK-NOHEADER-NOT: :8:5: warning: pass by value and use std::move [modernize-pass-by-value]
+// CHECK-SKIP-NOT:     :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)) {}
+// CHECK-SKIP-FIXES-NOT: #include <utility>
+//
+// header files are checked even without -header-filtler
+// CHECK-NOHEADER: Suppressed {{.*}} warnings
+// CHECK-NOHEADER: Use -header-filter={{.*}} to display errors{{.*}}
+//
+// header files are not checked with --skip-headers
+// CHECK-SKIP-NOT: Suppressed {{.*}} warnings
+// CHECK-SKIP-NOT: Use -header-filter={{.*}} to display errors{{.*}}

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-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]]:16: 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.cpp

+// Test --skip-headers, --show-all-warnings, and --header-filter.
+// TODO(chh): when skip-headers implementation is complete, add back
+//      -implicit-check-not="{{warning|error}}:"
+// and use no_hint instead of hint
+//
+// Default shows no warning in .h files, and give HINT to use --header-filter
+// RUN: clang-tidy %s -checks='*' -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes WARN,MAIN,HINT
+// later:    -implicit-check-not="{{warning|error}}:"
+//
+// --skip-headers skips included files; finds only warnings in the main file.
+// RUN: clang-tidy %s -checks='*' --skip-headers -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes WARN,MAIN,HINT
+// later:    no_hint -implicit-check-not="{{warning|error}}:"
+//
+// --show-all-warnings reports all warnings, even without --header-filters
+// RUN: clang-tidy %s -checks='*' --show-all-warnings -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes WARN,WARN_BOTH,MAIN,NO_HINT
+//
+// --header-filter='.*' is like --show-all-warnings
+// RUN: clang-tidy %s -checks='*' --header-filter='.*' -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes WARN,WARN_BOTH,MAIN,NO_HINT
+//
+// --header-filter='header1.h' shows only warnings in header1.h
+// RUN: clang-tidy %s -checks='*' --header-filter='header1.h' -- \
+// RUN: 2>&1 | FileCheck %s -check-prefixes WARN,WARN1,MAIN,HINT
+// later:    -implicit-check-not="{{warning|error}}:"
+//
+// The main purpose of --show-all-warnings is to debug --skip-headers.
+// When used together, 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 WARN,MAIN,NO_HINT
+// later:  -implicit-check-not="{{warning|error}}:"
+//
+// use --skip-headers and --header-filter='header2.h'
+// to skip header1.h but not header2.h
+// RUN: clang-tidy %s -checks='*' --skip-headers --header-filter='header2.h' \
+// RUN: 2>&1 | FileCheck %s -check-prefixes WARN,WARN2,MAIN,HINT
+// later:  no_hint
+
+// WARN: {{[0-9]+}} warnings generated.
+#include "Inputs/skip-headers/my_header1.h"
+// WARN1: my_header1.h:1:1: warning: header is missing header guard
+// WARN1-NOT: my_header2.h
+// WARN2: my_header2.h:1:1: warning: header is missing header guard
+// WARN2-NOT: my_header1.h
+// WARN_BOTH: my_header1.h:1:1: warning: header is missing header guard
+// WARN_BOTH: my_header2.h:1:1: warning: header is missing header guard
+
+int xyz = 135;
+// MAIN: skip-headers.cpp:{{[0-9]+}}:{{[0-9]+}}: warning:
+
+// HINT: Use -header-filter={{.*}} to display errors{{.*}}
+// NO_HINT-NOT: Use -header-filter=

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) = 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/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