[clang-tidy] Introduce HeaderFileExtensions and ImplementationFileExtensions options

[carlosgalvezp]

Summary

Re-introduce the patch that was reverted previously.
In the first attempt, the checks would not be able to
read from the global option, since getLocalOrGlobal
only works with string types. Additional logic is needed
in order to support both use cases in the transition
period. All that logic will be removed when the local
options are fully removed.

We have a number of checks designed to analyze problems
in header files only, for example:

bugprone-suspicious-include
google-build-namespaces
llvm-header-guard
misc-definitions-in-header
...

All these checks duplicate the same logic and options
to determine whether a location is placed in the main
source file or in the header. More checks are coming
up with similar requirements.

Thus, to remove duplication, let's move this option
to the top-level configuration of clang-tidy (since
it's something all checks should share).

Add a deprecation notice for all checks that use the
local option, prompting to update to the global option.

[carlosgalvezp]

Mark it as WIP to clarify it's not ready for review.

[carlosgalvezp]

Add functions to ClangTidyCheck so checks can get
access to them.

[carlosgalvezp]

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

233–234

@njames93 Would appreciate feedback on if putting these here sounds reasonable.

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

32–43

This is messy, but only needs to be kept during the transition period until the local option is fully removed. After that, checks simply need to call the function getHeaderFileExtensions() that is available via ClangTidyCheck where needed. Therefore, no more private local variables needed to handle this.

[PiotrZSL]

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

149

what about .c++ ? like file.c++ for implementation and h++ for header.
Its listed on https://en.wikibooks.org/wiki/C%2B%2B_Programming/Programming_Languages/C%2B%2B/Code/File_Organization

I know that probably no-one uses them, but who knows.

[carlosgalvezp]

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

149

First time I've seen it! If someone uses them they can add it in their config file, which is the purpose of this option :)

Anyhow the scope of this patch is not add new functionality, simply move the configuration from local to global options. I plan to add more default extensions (cuda, objc) in a follow up patch.

[carlosgalvezp]

• Apply fix to remaining checks.
• Fix documentation and release notes.

[carlosgalvezp]

Update commit message

[carlosgalvezp]

Use get functions from ClangTidyCheck instead of Context

[carlosgalvezp]

Update commit message to clarify the difference
between the first attempt and this one.

[carlosgalvezp]

Remove unneeded newlines and braces in single-line
if/else statements.

[carlosgalvezp]

Update commit message

[carlosgalvezp]

Fix release notes, ImplementationFileExtensions only
applies to one check.

[Eugene.Zelenko]

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

31

Will be good idea to make function in utils instead of code duplication.

[carlosgalvezp]

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

31

I thought about that, but found it quite difficult due to the dependencies to Options and diag(), which are only available in ClangTidyCheck. This is probably why there was duplication to begin with.

I could add a helper function in ClangTidyCheck, but I find it out of place and I see risk in people using it as if it were a solid function meant to stay. Since this code is temporary I think the duplication is a small price to pay for keeping backwards compatibility. It will all be gone when we remove the local options.

I might have missed something, if you have some concrete suggestion that could work I'm happy to use it!

[Eugene.Zelenko]

Looks OK for me, but please wait for other opinion(s).

[carlosgalvezp]

Document options now that the documentation improvement
patch is merged.

[carlosgalvezp]

Friendly ping @njames93 . Since there are more checks coming up introducing more debt and duplication, I believe we should land this rather soon. I intend to land this by Feb 19th if I don't receive any more feedback.

[carlosgalvezp]

• Rebase.
• Fix code directly for the newly introduce check in llvmlibc. We do not need the deprecation process here since the check is brand new.
• Rebase the getter functions from ClangTidyCheck.h, they don't seem to belong. Solve it by having each check that needs it store a copy of the file extensions, fetching it from the Context in the constructor of the check.

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

protected:
   StringRef getCurrentMainFile() const { return Context->getCurrentFile(); }
   /// Returns the language options from the context.
   const LangOptions &getLangOpts() const { return Context->getLangOpts(); }
   /// Returns true when the check is run in a use case when only 1 fix will be
   /// applied at a time.
   bool areDiagsSelfContained() const {
     return Context->areDiagsSelfContained();
   }
+  const FileExtensionsSet &getHeaderFileExtensions() const {
+    return Context->getHeaderFileExtensions();
+  }
+  const FileExtensionsSet &getImplementationFileExtensions() const {
+    return Context->getImplementationFileExtensions();
+  }
 };
 
 /// 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
 /// ``std::nullopt``.
 ///

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 "FileExtensionsSet.h"
 #include "NoLintDirectiveHandler.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Regex.h"
 #include <optional>
 
public:
   ///
   /// The \c CurrentFile can be changed using \c setCurrentFile.
   const ClangTidyOptions &getOptions() const;
 
   /// Returns options for \c File. Does not change or depend on
   /// \c CurrentFile.
   ClangTidyOptions getOptionsForFile(StringRef File) const;
 
+  const FileExtensionsSet &getHeaderFileExtensions() const {
+    return HeaderFileExtensions;
+  }
+
+  const FileExtensionsSet &getImplementationFileExtensions() const {
+    return ImplementationFileExtensions;
+  }
+
   /// Returns \c ClangTidyStats containing issued and ignored diagnostic
   /// counters.
   const ClangTidyStats &getStats() const { return Stats; }
 
   /// Control profile collection in clang-tidy.
   void setEnableProfiling(bool Profile);
   bool getEnableProfiling() const { return Profile; }
 
private:
   std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
 
   std::string CurrentFile;
   ClangTidyOptions CurrentOptions;
 
   std::unique_ptr<CachedGlobList> CheckFilter;
   std::unique_ptr<CachedGlobList> WarningAsErrorFilter;
 
+  FileExtensionsSet HeaderFileExtensions;
+  FileExtensionsSet ImplementationFileExtensions;
+
   LangOptions LangOpts;
 
   ClangTidyStats Stats;
 
   std::string CurrentBuildDirectory;
 
   llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
 

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

 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
 #include "GlobList.h"
 #include "NoLintDirectiveHandler.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/Attr.h"
+#include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/DiagnosticRenderer.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/Core/Replacement.h"
bool ClangTidyContext::shouldSuppressDiagnostic(
   return NoLintHandler.shouldSuppress(DiagLevel, Info, CheckName, NoLintErrors,
                                       AllowIO, EnableNoLintBlocks);
 }
 
 void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
   DiagEngine->setSourceManager(SourceMgr);
 }
 
+static bool
+parseFileExtensions(const std::vector<std::string> &AllFileExtensions,
+                    FileExtensionsSet &FileExtensions) {
+  FileExtensions.clear();
+  for (StringRef Suffix : AllFileExtensions) {
+    StringRef Extension = Suffix.trim();
+    if (!llvm::all_of(Extension, isAlphanumeric))
+      return false;
+    FileExtensions.insert(Extension);
+  }
+  return true;
+}
+
 void ClangTidyContext::setCurrentFile(StringRef File) {
   CurrentFile = std::string(File);
   CurrentOptions = getOptionsForFile(CurrentFile);
   CheckFilter = std::make_unique<CachedGlobList>(*getOptions().Checks);
   WarningAsErrorFilter =
       std::make_unique<CachedGlobList>(*getOptions().WarningsAsErrors);
+
+  if (!parseFileExtensions(*getOptions().HeaderFileExtensions,
+                           HeaderFileExtensions)) {
+    this->configurationDiag("Invalid header file extensions");
+  }
+
+  if (!parseFileExtensions(*getOptions().ImplementationFileExtensions,
+                           ImplementationFileExtensions)) {
+    this->configurationDiag("Invalid implementation file extensions");
+  }
 }
 
 void ClangTidyContext::setASTContext(ASTContext *Context) {
   DiagEngine->SetArgToStringFn(&FormatASTNodeDiagnosticArgument, Context);
   LangOpts = Context->getLangOpts();
 }
 
 const ClangTidyGlobalOptions &ClangTidyContext::getGlobalOptions() const {

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

[[nodiscard]] ClangTidyOptions merge(const ClangTidyOptions &Other,
                                        unsigned Order) const;
 
   /// Checks filter.
   std::optional<std::string> Checks;
 
   /// WarningsAsErrors filter.
   std::optional<std::string> WarningsAsErrors;
 
+  /// File extensions to consider to determine if a given diagnostic is located
+  /// in a header file.
+  std::optional<std::vector<std::string>> HeaderFileExtensions;
+
+  /// File extensions to consider to determine if a given diagnostic is located
+  /// is located in an implementation file.
+  std::optional<std::vector<std::string>> ImplementationFileExtensions;
+
   /// Output warnings from headers matching this filter. Warnings from
   /// main files will always be displayed.
   std::optional<std::string> HeaderFilterRegex;
 
   /// Output warnings from system headers matching \c HeaderFilterRegex.
   std::optional<bool> SystemHeaders;
 
   /// Format code around applied fixes with clang-format using this

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

void yamlize(IO &IO, ClangTidyOptions::OptionMap &Options, bool,
   }
 }
 
 template <> struct MappingTraits<ClangTidyOptions> {
   static void mapping(IO &IO, ClangTidyOptions &Options) {
     bool Ignored = false;
     IO.mapOptional("Checks", Options.Checks);
     IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
+    IO.mapOptional("HeaderFileExtensions", Options.HeaderFileExtensions);
+    IO.mapOptional("ImplementationFileExtensions",
+                   Options.ImplementationFileExtensions);
     IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
     IO.mapOptional("AnalyzeTemporaryDtors", Ignored); // deprecated
     IO.mapOptional("FormatStyle", Options.FormatStyle);
     IO.mapOptional("User", Options.User);
     IO.mapOptional("CheckOptions", Options.CheckOptions);
     IO.mapOptional("ExtraArgs", Options.ExtraArgs);
     IO.mapOptional("ExtraArgsBefore", Options.ExtraArgsBefore);
     IO.mapOptional("InheritParentConfig", Options.InheritParentConfig);
     IO.mapOptional("UseColor", Options.UseColor);
   }
 };
 
 } // namespace llvm::yaml
 
 namespace clang::tidy {
 
 ClangTidyOptions ClangTidyOptions::getDefaults() {
   ClangTidyOptions Options;
   Options.Checks = "";
   Options.WarningsAsErrors = "";
+  Options.HeaderFileExtensions = {"", "h", "hh", "hpp", "hxx"};
+  Options.ImplementationFileExtensions = {"c", "cc", "cpp", "cxx"};
   Options.HeaderFilterRegex = "";
   Options.SystemHeaders = false;
   Options.FormatStyle = "none";
   Options.User = std::nullopt;
   for (const ClangTidyModuleRegistry::entry &Module :
        ClangTidyModuleRegistry::entries())
     Options.mergeWith(Module.instantiate()->getModuleOptions(), 0);
   return Options;
static void overrideValue(std::optional<T> &Dest, const std::optional<T> &Src) {
   if (Src)
     Dest = Src;
 }
 
 ClangTidyOptions &ClangTidyOptions::mergeWith(const ClangTidyOptions &Other,
                                               unsigned Order) {
   mergeCommaSeparatedLists(Checks, Other.Checks);
   mergeCommaSeparatedLists(WarningsAsErrors, Other.WarningsAsErrors);
+  overrideValue(HeaderFileExtensions, Other.HeaderFileExtensions);
+  overrideValue(ImplementationFileExtensions,
+                Other.ImplementationFileExtensions);
   overrideValue(HeaderFilterRegex, Other.HeaderFilterRegex);
   overrideValue(SystemHeaders, Other.SystemHeaders);
   overrideValue(FormatStyle, Other.FormatStyle);
   overrideValue(User, Other.User);
   overrideValue(UseColor, Other.UseColor);
   mergeVectors(ExtraArgs, Other.ExtraArgs);
   mergeVectors(ExtraArgsBefore, Other.ExtraArgsBefore);
 

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

+//===--- FileExtensionsSet.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_FILE_EXTENSIONS_SET_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FILE_EXTENSIONS_SET_H
+
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clang::tidy {
+typedef llvm::SmallSet<llvm::StringRef, 5> FileExtensionsSet;
+} // namespace clang::tidy
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FILE_EXTENSIONS_SET_H

clang-tools-extra/clang-tidy/bugprone/DynamicStaticInitializersCheck.h

 //===--- DynamicStaticInitializersCheck.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_BUGPRONE_DYNAMIC_STATIC_INITIALIZERS_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_DYNAMIC_STATIC_INITIALIZERS_CHECK_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/FileExtensionsUtils.h"
+#include "../FileExtensionsSet.h"
 
 namespace clang::tidy::bugprone {
 
 /// Finds dynamically initialized static variables in header files.
 ///
 /// The check supports these options:
 ///   - `HeaderFileExtensions`: a semicolon-separated list of filename
 ///     extensions of header files (The filename extensions should not contain
 ///     "." prefix). ";h;hh;hpp;hxx" by default.
 //
 ///     For extension-less header files, using an empty string or leaving an
 ///     empty string between ";" if there are other filename extensions.
 class DynamicStaticInitializersCheck : public ClangTidyCheck {
 public:
   DynamicStaticInitializersCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus && !LangOpts.ThreadsafeStatics;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const StringRef RawStringHeaderFileExtensions;
-  utils::FileExtensionsSet HeaderFileExtensions;
+  StringRef RawStringHeaderFileExtensions;
+  FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace clang::tidy::bugprone
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_DYNAMIC_STATIC_INITIALIZERS_CHECK_H

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

 //===--- DynamicStaticInitializersCheck.cpp - clang-tidy ------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "DynamicStaticInitializersCheck.h"
+#include "../utils/FileExtensionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::bugprone {
 
 AST_MATCHER(clang::VarDecl, hasConstantDeclaration) {
   const Expr *Init = Node.getInit();
   if (Init && !Init->isValueDependent()) {
     if (Node.isConstexpr())
       return true;
     return Node.evaluateValue();
   }
   return false;
 }
 
-DynamicStaticInitializersCheck::DynamicStaticInitializersCheck(StringRef Name,
-                                                               ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
-        "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
+DynamicStaticInitializersCheck::DynamicStaticInitializersCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context) {
+  std::optional<StringRef> HeaderFileExtensionsOption =
+      Options.get("HeaderFileExtensions");
+  RawStringHeaderFileExtensions =
+      HeaderFileExtensionsOption.value_or(utils::defaultHeaderFileExtensions());
+  if (HeaderFileExtensionsOption) {
     if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                     HeaderFileExtensions,
                                     utils::defaultFileExtensionDelimiters())) {
       this->configurationDiag("Invalid header file extension: '%0'")
           << RawStringHeaderFileExtensions;
     }
+  } else
+    HeaderFileExtensions = getHeaderFileExtensions();
 }
 
 void DynamicStaticInitializersCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);
 }
 
 void DynamicStaticInitializersCheck::registerMatchers(MatchFinder *Finder) {

clang-tools-extra/clang-tidy/bugprone/SuspiciousIncludeCheck.h

 /// http://clang.llvm.org/extra/clang-tidy/checks/bugprone/suspicious-include.html
 class SuspiciousIncludeCheck : public ClangTidyCheck {
 public:
   SuspiciousIncludeCheck(StringRef Name, ClangTidyContext *Context);
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
-  utils::FileExtensionsSet HeaderFileExtensions;
-  utils::FileExtensionsSet ImplementationFileExtensions;
+  FileExtensionsSet HeaderFileExtensions;
+  FileExtensionsSet ImplementationFileExtensions;
 
 private:
-  const StringRef RawStringHeaderFileExtensions;
-  const StringRef RawStringImplementationFileExtensions;
+  StringRef RawStringHeaderFileExtensions;
+  StringRef RawStringImplementationFileExtensions;
 };
 
 } // namespace clang::tidy::bugprone
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSINCLUDECHECK_H

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

 //===--- SuspiciousIncludeCheck.cpp - clang-tidy --------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "SuspiciousIncludeCheck.h"
+#include "../utils/FileExtensionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Lex/Preprocessor.h"
 #include <optional>
 
 namespace clang::tidy::bugprone {
 
 namespace {
 class SuspiciousIncludePPCallbacks : public PPCallbacks {

 private:
   SuspiciousIncludeCheck &Check;
   Preprocessor *PP;
 };
 } // namespace
 
 SuspiciousIncludeCheck::SuspiciousIncludeCheck(StringRef Name,
                                                ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
-          "HeaderFileExtensions", utils::defaultHeaderFileExtensions())),
-      RawStringImplementationFileExtensions(Options.getLocalOrGlobal(
-          "ImplementationFileExtensions",
-          utils::defaultImplementationFileExtensions())) {
+    : ClangTidyCheck(Name, Context) {
+  std::optional<StringRef> ImplementationFileExtensionsOption =
+      Options.get("ImplementationFileExtensions");
+  RawStringImplementationFileExtensions =
+      ImplementationFileExtensionsOption.value_or(
+          utils::defaultImplementationFileExtensions());
+  if (ImplementationFileExtensionsOption) {
     if (!utils::parseFileExtensions(RawStringImplementationFileExtensions,
                                     ImplementationFileExtensions,
                                     utils::defaultFileExtensionDelimiters())) {
       this->configurationDiag("Invalid implementation file extension: '%0'")
           << RawStringImplementationFileExtensions;
     }
+  } else
+    ImplementationFileExtensions = getImplementationFileExtensions();
 
+  std::optional<StringRef> HeaderFileExtensionsOption =
+      Options.get("HeaderFileExtensions");
+  RawStringHeaderFileExtensions =
+      HeaderFileExtensionsOption.value_or(utils::defaultHeaderFileExtensions());
+  if (HeaderFileExtensionsOption) {
     if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                     HeaderFileExtensions,
                                     utils::defaultFileExtensionDelimiters())) {
       this->configurationDiag("Invalid header file extension: '%0'")
           << RawStringHeaderFileExtensions;
     }
+  } else
+    HeaderFileExtensions = getHeaderFileExtensions();
 }
 
 void SuspiciousIncludeCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "ImplementationFileExtensions",
                 RawStringImplementationFileExtensions);
   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);
 }
 

clang-tools-extra/clang-tidy/google/GlobalNamesInHeadersCheck.h

 class GlobalNamesInHeadersCheck : public ClangTidyCheck {
 public:
   GlobalNamesInHeadersCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const StringRef RawStringHeaderFileExtensions;
-  utils::FileExtensionsSet HeaderFileExtensions;
+  StringRef RawStringHeaderFileExtensions;
+  FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace clang::tidy::google::readability
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GLOBALNAMESINHEADERSCHECK_H

clang-tools-extra/clang-tidy/google/GlobalNamesInHeadersCheck.cpp

 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::google::readability {
 
 GlobalNamesInHeadersCheck::GlobalNamesInHeadersCheck(StringRef Name,
                                                      ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
-          "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
+    : ClangTidyCheck(Name, Context) {
+  std::optional<StringRef> HeaderFileExtensionsOption =
+      Options.get("HeaderFileExtensions");
+  RawStringHeaderFileExtensions =
+      HeaderFileExtensionsOption.value_or(utils::defaultHeaderFileExtensions());
+  if (HeaderFileExtensionsOption) {
     if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                     HeaderFileExtensions,
                                     utils::defaultFileExtensionDelimiters())) {
       this->configurationDiag("Invalid header file extension: '%0'")
           << RawStringHeaderFileExtensions;
     }
+  } else
+    HeaderFileExtensions = getHeaderFileExtensions();
 }
 
 void GlobalNamesInHeadersCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);
 }
 
 void GlobalNamesInHeadersCheck::registerMatchers(

clang-tools-extra/clang-tidy/google/UnnamedNamespaceInHeaderCheck.h

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const StringRef RawStringHeaderFileExtensions;
-  utils::FileExtensionsSet HeaderFileExtensions;
+  StringRef RawStringHeaderFileExtensions;
+  FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace clang::tidy::google::build
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_UNNAMEDNAMESPACEINHEADERCHECK_H

clang-tools-extra/clang-tidy/google/UnnamedNamespaceInHeaderCheck.cpp

 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::google::build {
 
 UnnamedNamespaceInHeaderCheck::UnnamedNamespaceInHeaderCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
-          "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
+    : ClangTidyCheck(Name, Context) {
+  std::optional<StringRef> HeaderFileExtensionsOption =
+      Options.get("HeaderFileExtensions");
+  RawStringHeaderFileExtensions =
+      HeaderFileExtensionsOption.value_or(utils::defaultHeaderFileExtensions());
+  if (HeaderFileExtensionsOption) {
     if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                     HeaderFileExtensions,
                                     utils::defaultFileExtensionDelimiters())) {
       this->configurationDiag("Invalid header file extension: '%0'")
           << RawStringHeaderFileExtensions;
     }
+  } else
+    HeaderFileExtensions = getHeaderFileExtensions();
 }
 
 void UnnamedNamespaceInHeaderCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);
 }
 
 void UnnamedNamespaceInHeaderCheck::registerMatchers(

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

bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool UseHeaderFileExtension;
-  const StringRef RawStringHeaderFileExtensions;
-  utils::FileExtensionsSet HeaderFileExtensions;
+  StringRef RawStringHeaderFileExtensions;
+  FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace clang::tidy::misc
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONS_IN_HEADERS_H

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

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::misc {
 
 namespace {
 
-AST_MATCHER_P(NamedDecl, usesHeaderFileExtension, utils::FileExtensionsSet,
+AST_MATCHER_P(NamedDecl, usesHeaderFileExtension, FileExtensionsSet,
               HeaderFileExtensions) {
   return utils::isExpansionLocInHeaderFile(
       Node.getBeginLoc(), Finder->getASTContext().getSourceManager(),
       HeaderFileExtensions);
 }
 
 } // namespace
 
 DefinitionsInHeadersCheck::DefinitionsInHeadersCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      UseHeaderFileExtension(Options.get("UseHeaderFileExtension", true)),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
-          "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
+      UseHeaderFileExtension(Options.get("UseHeaderFileExtension", true)) {
+  std::optional<StringRef> HeaderFileExtensionsOption =
+      Options.get("HeaderFileExtensions");
+  RawStringHeaderFileExtensions =
+      HeaderFileExtensionsOption.value_or(utils::defaultHeaderFileExtensions());
+  if (HeaderFileExtensionsOption) {
     if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                     HeaderFileExtensions,
                                     utils::defaultFileExtensionDelimiters())) {
       this->configurationDiag("Invalid header file extension: '%0'")
           << RawStringHeaderFileExtensions;
     }
+  } else
+    HeaderFileExtensions = getHeaderFileExtensions();
 }
 
 void DefinitionsInHeadersCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "UseHeaderFileExtension", UseHeaderFileExtension);
   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);
 }
 

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

struct UsingDeclContext {
     // The source range of the UsingDecl.
     CharSourceRange UsingDeclRange;
     // Whether the UsingDecl is used.
     bool IsUsed;
   };
 
   std::vector<UsingDeclContext> Contexts;
 
-  const StringRef RawStringHeaderFileExtensions;
-  utils::FileExtensionsSet HeaderFileExtensions;
+  StringRef RawStringHeaderFileExtensions;
+  FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace clang::tidy::misc
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_USING_DECLS_H

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

static bool shouldCheckDecl(const Decl *TargetDecl) {
   return isa<RecordDecl>(TargetDecl) || isa<ClassTemplateDecl>(TargetDecl) ||
          isa<FunctionDecl>(TargetDecl) || isa<VarDecl>(TargetDecl) ||
          isa<FunctionTemplateDecl>(TargetDecl) || isa<EnumDecl>(TargetDecl) ||
          isa<EnumConstantDecl>(TargetDecl);
 }
 
 UnusedUsingDeclsCheck::UnusedUsingDeclsCheck(StringRef Name,
                                              ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
-          "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
+    : ClangTidyCheck(Name, Context) {
+  std::optional<StringRef> HeaderFileExtensionsOption =
+      Options.get("HeaderFileExtensions");
+  RawStringHeaderFileExtensions =
+      HeaderFileExtensionsOption.value_or(utils::defaultHeaderFileExtensions());
+  if (HeaderFileExtensionsOption) {
     if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                     HeaderFileExtensions,
-                                  utils::defaultFileExtensionDelimiters()))
+                                    utils::defaultFileExtensionDelimiters())) {
       this->configurationDiag("Invalid header file extension: '%0'")
           << RawStringHeaderFileExtensions;
     }
+  } else
+    HeaderFileExtensions = getHeaderFileExtensions();
+}
 
 void UnusedUsingDeclsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(usingDecl(isExpansionInMainFile()).bind("using"), this);
   auto DeclMatcher = hasDeclaration(namedDecl().bind("used"));
   Finder->addMatcher(loc(templateSpecializationType(DeclMatcher)), this);
   Finder->addMatcher(loc(deducedTemplateSpecializationType(
                          refsToTemplatedDecl(namedDecl().bind("used")))),
                      this);

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

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  const StringRef RawStringHeaderFileExtensions;
-  utils::FileExtensionsSet HeaderFileExtensions;
+  StringRef RawStringHeaderFileExtensions;
+  FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace clang::tidy::misc
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_USEANONYMOUSNAMESPACECHECK_H

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

 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::misc {
 namespace {
 AST_POLYMORPHIC_MATCHER_P(isInHeaderFile,
                           AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl,
                                                           VarDecl),
-                          utils::FileExtensionsSet, HeaderFileExtensions) {
+                          FileExtensionsSet, HeaderFileExtensions) {
   return utils::isExpansionLocInHeaderFile(
       Node.getBeginLoc(), Finder->getASTContext().getSourceManager(),
       HeaderFileExtensions);
 }
 
 AST_MATCHER(FunctionDecl, isMemberFunction) {
   return llvm::isa<CXXMethodDecl>(&Node);
 }
 AST_MATCHER(VarDecl, isStaticDataMember) { return Node.isStaticDataMember(); }
 } // namespace
 
 UseAnonymousNamespaceCheck::UseAnonymousNamespaceCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
-          "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
+    : ClangTidyCheck(Name, Context) {
+  std::optional<StringRef> HeaderFileExtensionsOption =
+      Options.get("HeaderFileExtensions");
+  RawStringHeaderFileExtensions =
+      HeaderFileExtensionsOption.value_or(utils::defaultHeaderFileExtensions());
+  if (HeaderFileExtensionsOption) {
     if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
                                     HeaderFileExtensions,
                                     utils::defaultFileExtensionDelimiters())) {
       this->configurationDiag("Invalid header file extension: '%0'")
           << RawStringHeaderFileExtensions;
     }
+  } else
+    HeaderFileExtensions = getHeaderFileExtensions();
 }
 
 void UseAnonymousNamespaceCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);
 }
 
 void UseAnonymousNamespaceCheck::registerMatchers(MatchFinder *Finder) {

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

Configuration files:
   file. If InheritParentConfig is true in a config file, the configuration file
   in the parent directory (if any exists) will be taken and current config file
   will be applied on top of the parent one. If any configuration options have
   a corresponding command-line option, command-line option takes precedence.
   The effective configuration can be inspected using -dump-config:
 
     $ clang-tidy -dump-config
     ---
-    Checks:              '-*,some-check'
-    WarningsAsErrors:    ''
-    HeaderFilterRegex:   ''
-    FormatStyle:         none
-    InheritParentConfig: true
-    User:                user
+    Checks:                       '-*,some-check'
+    WarningsAsErrors:             ''
+    HeaderFileExtensions:         ['', 'h','hh','hpp','hxx']
+    ImplementationFileExtensions: ['c','cc','cpp','cxx']
+    HeaderFilterRegex:            ''
+    FormatStyle:                  none
+    InheritParentConfig:          true
+    User:                         user
     CheckOptions:
       some-check.SomeOption: 'some value'
     ...
 
 )");
 
 const char DefaultChecks[] = // Enable these checks by default:
     "clang-diagnostic-*,"    //   * compiler diagnostics

 Apply suggested fixes even if compilation
 errors were found. If compiler errors have
 attached fix-its, clang-tidy will apply them as
 well.
 )"),
                                cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<bool> FixNotes("fix-notes", cl::desc(R"(
-If a warning has no fix, but a single fix can 
-be found through an associated diagnostic note, 
-apply the fix. 
-Specifying this flag will implicitly enable the 
+If a warning has no fix, but a single fix can
+be found through an associated diagnostic note,
+apply the fix.
+Specifying this flag will implicitly enable the
 '--fix' flag.
 )"),
                               cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<std::string> FormatStyle("format-style", cl::desc(R"(
 Style for formatting code around applied fixes:
   - 'none' (default) turns off formatting
   - 'file' (literally 'file', not a placeholder)
if (Cur.contains('*')) {
       if (!Closest.empty())
         Output << "; did you mean '" << Closest << '\'';
       Output << VerifyConfigWarningEnd;
     }
   }
   return AnyInvalid;
 }
 
+static bool verifyFileExtensions(
+    const std::vector<std::string> &HeaderFileExtensions,
+    const std::vector<std::string> &ImplementationFileExtensions,
+    StringRef Source) {
+  bool AnyInvalid = false;
+  for (const auto &HeaderExtension : HeaderFileExtensions) {
+    for (const auto &ImplementationExtension : ImplementationFileExtensions) {
+      if (HeaderExtension == ImplementationExtension) {
+        AnyInvalid = true;
+        auto &Output = llvm::WithColor::warning(llvm::errs(), Source)
+                       << "HeaderFileExtension '" << HeaderExtension << '\''
+                       << " is the same as ImplementationFileExtension '"
+                       << ImplementationExtension << '\'';
+        Output << VerifyConfigWarningEnd;
+      }
+    }
+  }
+  return AnyInvalid;
+}
+
 int clangTidyMain(int argc, const char **argv) {
   llvm::InitLLVM X(argc, argv);
 
   // Enable help for -load option, if plugins are enabled.
   if (cl::Option *LoadOpt = cl::getRegisteredOptions().lookup("load"))
     LoadOpt->addCategory(ClangTidyCategory);
 
   llvm::Expected<CommonOptionsParser> OptionsParser =
std::vector<ClangTidyOptionsProvider::OptionsSource> RawOptions =
         OptionsProvider->getRawOptions(FileName);
     NamesAndOptions Valid =
         getAllChecksAndOptions(AllowEnablingAnalyzerAlphaCheckers);
     bool AnyInvalid = false;
     for (const auto &[Opts, Source] : RawOptions) {
       if (Opts.Checks)
         AnyInvalid |= verifyChecks(Valid.Names, *Opts.Checks, Source);
 
+      if (Opts.HeaderFileExtensions && Opts.ImplementationFileExtensions)
+        AnyInvalid |=
+            verifyFileExtensions(*Opts.HeaderFileExtensions,
+                                 *Opts.ImplementationFileExtensions, Source);
+
       for (auto Key : Opts.CheckOptions.keys()) {
         if (Valid.Options.contains(Key))
           continue;
         AnyInvalid = true;
         auto &Output = llvm::WithColor::warning(llvm::errs(), Source)
                        << "unknown check option '" << Key << '\'';
         llvm::StringRef Closest = closest(Key, Valid.Options);
         if (!Closest.empty())

clang-tools-extra/clang-tidy/utils/FileExtensionsUtils.h

 //===--- FileExtensionsUtils.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_UTILS_FILE_EXTENSIONS_UTILS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FILE_EXTENSIONS_UTILS_H
 
+#include "../FileExtensionsSet.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringRef.h"
 #include <optional>
 
 namespace clang::tidy::utils {
 
-typedef llvm::SmallSet<llvm::StringRef, 5> FileExtensionsSet;
-
 /// Checks whether expansion location of \p Loc is in header file.
 bool isExpansionLocInHeaderFile(SourceLocation Loc, const SourceManager &SM,
                                 const FileExtensionsSet &HeaderFileExtensions);
 
 /// Checks whether presumed location of \p Loc is in header file.
 bool isPresumedLocInHeaderFile(SourceLocation Loc, SourceManager &SM,
                                const FileExtensionsSet &HeaderFileExtensions);
 

clang-tools-extra/clang-tidy/utils/HeaderGuard.h

 ///     extensions of header files (The filename extension should not contain
 ///     "." prefix). ";h;hh;hpp;hxx" by default.
 ///
 ///     For extension-less header files, using an empty string or leaving an
 ///     empty string between ";" if there are other filename extensions.
 class HeaderGuardCheck : public ClangTidyCheck {
 public:
   HeaderGuardCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context),
-        RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
-            "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
-    utils::parseFileExtensions(RawStringHeaderFileExtensions,
-                               HeaderFileExtensions,
-                               utils::defaultFileExtensionDelimiters());
+      : ClangTidyCheck(Name, Context) {
+    std::optional<StringRef> HeaderFileExtensionsOption =
+        Options.get("HeaderFileExtensions");
+    RawStringHeaderFileExtensions = HeaderFileExtensionsOption.value_or(
+        utils::defaultHeaderFileExtensions());
+    if (HeaderFileExtensionsOption) {
+      if (!utils::parseFileExtensions(
+              RawStringHeaderFileExtensions, HeaderFileExtensions,
+              utils::defaultFileExtensionDelimiters())) {
+        this->configurationDiag("Invalid header file extension: '%0'")
+            << RawStringHeaderFileExtensions;
+      }
+    } else
+      HeaderFileExtensions = getHeaderFileExtensions();
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
 
   /// Ensure that the provided header guard is a non-reserved identifier.
   std::string sanitizeHeaderGuard(StringRef Guard);
 
public:
   /// \p HeaderGuard. The replacement should start with ``endif``.
   virtual std::string formatEndIf(StringRef HeaderGuard);
   /// Gets the canonical header guard for a file.
   virtual std::string getHeaderGuard(StringRef Filename,
                                      StringRef OldGuard = StringRef()) = 0;
 
 private:
   std::string RawStringHeaderFileExtensions;
-  utils::FileExtensionsSet HeaderFileExtensions;
+  FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace clang::tidy::utils
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADERGUARD_H

clang-tools-extra/docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+- New global configuration file options `HeaderFileExtensions` and
+  `ImplementationFileExtensions`, replacing the check-local options of the
+  same name.
+
 New checks
 ^^^^^^^^^^
 
 - New :doc:`bugprone-unsafe-functions
   <clang-tidy/checks/bugprone/unsafe-functions>` check.
 
   Checks for functions that have safer, more secure replacements available, or
   are considered deprecated due to design flaws.

 
 - New alias :doc:`cert-msc33-c
   <clang-tidy/checks/cert/msc33-c>` to :doc:`bugprone-unsafe-functions
   <clang-tidy/checks/bugprone/unsafe-functions>` was added.
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+- Deprecated check-local options `HeaderFileExtensions` and `ImplementationFileExtensions`
+  in :doc:`bugprone-dynamic-static-initializers
+  <clang-tidy/checks/bugprone/dynamic-static-initializers>` check.
+  Global options of the same name should be used instead.
+
+- Deprecated check-local options `HeaderFileExtensions` and `ImplementationFileExtensions`
+  in :doc:`bugprone-suspicious-include
+  <clang-tidy/checks/bugprone/suspicious-include>` check.
+  Global options of the same name should be used instead.
+
+- Deprecated check-local options `HeaderFileExtensions` and `ImplementationFileExtensions`
+  in :doc:`google-build-namespaces
+  <clang-tidy/checks/google/build-namespaces>` check.
+  Global options of the same name should be used instead.
+
+- Deprecated check-local options `HeaderFileExtensions` and `ImplementationFileExtensions`
+  in :doc:`google-global-names-in-headers
+  <clang-tidy/checks/google/global-names-in-headers>` check.
+  Global options of the same name should be used instead.
+
+- Deprecated check-local options `HeaderFileExtensions` and `ImplementationFileExtensions`
+  in :doc:`llvm-header-guard
+  <clang-tidy/checks/llvm/header-guard>` check.
+  Global options of the same name should be used instead.
+
+- Deprecated check-local options `HeaderFileExtensions` and `ImplementationFileExtensions`
+  in :doc:`misc-definitions-in-headers
+  <clang-tidy/checks/misc/definitions-in-headers>` check.
+  Global options of the same name should be used instead.
+
+- Deprecated check-local options `HeaderFileExtensions` and `ImplementationFileExtensions`
+  in :doc:`misc-unused-using-decls
+  <clang-tidy/checks/misc/misc-unused-using-decls>` check.
+  Global options of the same name should be used instead.
+
 Removed checks
 ^^^^^^^^^^^^^^
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 

clang-tools-extra/docs/clang-tidy/checks/bugprone/suspicious-include.rst

.. code-block:: c++
   #include "Pterodactyl.h"    // OK, .h files tend not to have definitions.
   #include "Velociraptor.cpp" // Warning, filename is suspicious.
   #include_next <stdio.c>     // Warning, filename is suspicious.
 
 Options
 -------
 .. option:: HeaderFileExtensions
 
+   Note: this option is deprecated, it will be removed in :program:`clang-tidy`
+   version 19. Please use the global configuration option
+   `HeaderFileExtensions`.
+
    Default value: ``";h;hh;hpp;hxx"``
    A semicolon-separated list of filename extensions of header files (the
    filename extensions should not contain a "." prefix). For extension-less
    header files, use an empty string or leave an empty string between ";"
    if there are other filename extensions.
 
 .. option:: ImplementationFileExtensions
 
+   Note: this option is deprecated, it will be removed in :program:`clang-tidy`
+   version 19. Please use the global configuration option
+   `ImplementationFileExtensions`.
+
    Default value: ``"c;cc;cpp;cxx"``
    Likewise, a semicolon-separated list of filename extensions of
    implementation files.

clang-tools-extra/docs/clang-tidy/checks/google/build-namespaces.rst

 
 Corresponding cpplint.py check name: `build/namespaces`.
 
 Options
 -------
 
 .. option:: HeaderFileExtensions
 
+   Note: this option is deprecated, it will be removed in :program:`clang-tidy`
+   version 19. Please use the global configuration option
+   `HeaderFileExtensions`.
+
    A comma-separated list of filename extensions of header files (the filename
    extensions should not include "." prefix). Default is "h,hh,hpp,hxx".
    For header files without an extension, use an empty string (if there are no
    other desired extensions) or leave an empty element in the list. E.g.,
    "h,hh,hpp,hxx," (note the trailing comma).

clang-tools-extra/docs/clang-tidy/checks/google/global-names-in-headers.rst

 .. title:: clang-tidy - google-global-names-in-headers
 
 google-global-names-in-headers
 ==============================
 
 Flag global namespace pollution in header files. Right now it only triggers on
 ``using`` declarations and directives.
 
 The relevant style guide section is
 https://google.github.io/styleguide/cppguide.html#Namespaces.
 
 Options
 -------
 
 .. option:: HeaderFileExtensions
 
+   Note: this option is deprecated, it will be removed in :program:`clang-tidy`
+   version 19. Please use the global configuration option
+   `HeaderFileExtensions`.
+
    A comma-separated list of filename extensions of header files (the filename
    extensions should not contain "." prefix). Default is "h".
    For header files without an extension, use an empty string (if there are no
    other desired extensions) or leave an empty element in the list. E.g.,
    "h,hh,hpp,hxx," (note the trailing comma).

clang-tools-extra/docs/clang-tidy/checks/llvm/header-guard.rst

 .. title:: clang-tidy - llvm-header-guard
 
 llvm-header-guard
 =================
 
 Finds and fixes header guards that do not adhere to LLVM style.
 
 Options
 -------
 
 .. option:: HeaderFileExtensions
 
+   Note: this option is deprecated, it will be removed in :program:`clang-tidy`
+   version 19. Please use the global configuration option
+   `HeaderFileExtensions`.
+
    A comma-separated list of filename extensions of header files (the filename
    extensions should not include "." prefix). Default is "h,hh,hpp,hxx".
    For header files without an extension, use an empty string (if there are no
    other desired extensions) or leave an empty element in the list. E.g.,
    "h,hh,hpp,hxx," (note the trailing comma).

clang-tools-extra/docs/clang-tidy/checks/misc/definitions-in-headers.rst

.. code-block:: c++
    template <class T>
    constexpr T pi = T(3.1415926L);
 
 Options
 -------
 
 .. option:: HeaderFileExtensions
 
+   Note: this option is deprecated, it will be removed in :program:`clang-tidy`
+   version 19. Please use the global configuration option
+   `HeaderFileExtensions`.
+
    A comma-separated list of filename extensions of header files (the filename
    extensions should not include "." prefix). Default is "h,hh,hpp,hxx".
    For header files without an extension, use an empty string (if there are no
    other desired extensions) or leave an empty element in the list. E.g.,
    "h,hh,hpp,hxx," (note the trailing comma).
 
 .. option:: UseHeaderFileExtension
 
+   Note: this option is deprecated, it will be removed in :program:`clang-tidy`
+   version 19. The check will unconditionally use the global option
+   `HeaderFileExtensions`.
+
    When `true`, the check will use the file extension to distinguish header
    files. Default is `true`.

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

.. code-block:: c++
   namespace n { class C; }
   using n::C;  // Never actually used.
 
 Options
 -------
 
 .. option:: HeaderFileExtensions
 
+   Note: this option is deprecated, it will be removed in :program:`clang-tidy`
+   version 19. Please use the global configuration option
+   `HeaderFileExtensions`.
+
    A semicolon-separated list of filename extensions of header files (the filename
    extensions should not include "." prefix). Default is "h,hh,hpp,hxx".
    For extension-less header files, use an empty string or leave an
    empty string between "," if there are other filename extensions.

clang-tools-extra/docs/clang-tidy/checks/misc/use-anonymous-namespace.rst

namespace {
     int x;
   } // namespace
 
 Options
 -------
 
 .. option:: HeaderFileExtensions
 
+   Note: this option is deprecated, it will be removed in :program:`clang-tidy`
+   version 19. Please use the global configuration option
+   `HeaderFileExtensions`.
+
    A semicolon-separated list of filename extensions of header files (the filename
    extensions should not include "." prefix). Default is ";h;hh;hpp;hxx".
    For extension-less header files, using an empty string or leaving an
    empty string between ";" if there are other filename extensions.
 
 [1] `Undeprecating static <https://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1012>`_

clang-tools-extra/docs/clang-tidy/index.rst

--checks=<string>              -
                                      file, if any.
     --config=<string>              -
                                      Specifies a configuration in YAML/JSON format:
                                        -config="{Checks: '*',
                                                  CheckOptions: {x, y}}"
                                      When the value is empty, clang-tidy will
                                      attempt to find a file named .clang-tidy for
                                      each source file in its parent directories.
-    --config-file=<string>         - 
+    --config-file=<string>         -
                                     Specify the path of .clang-tidy or custom config file:
                                       e.g. --config-file=/some/path/myTidyConfigFile
                                     This option internally works exactly the same way as
                                       --config option after reading specified config file.
                                     Use either --config-file or --config, not both.
     --dump-config                  -
                                      Dumps configuration in the YAML format to
                                      stdout. This option can be used along with a
--quiet                        -
                                      printing statistics about ignored warnings and
                                      warnings treated as errors if the respective
                                      options are specified.
     --store-check-profile=<prefix> -
                                      By default reports are printed in tabulated
                                      format to stderr. When this option is passed,
                                      these per-TU profiles are instead stored as JSON.
     --system-headers               - Display the errors from system headers.
-    --use-color                    - 
+    --use-color                    -
                                     Use colors in diagnostics. If not set, colors
                                     will be used if the terminal connected to
                                     standard output supports colors.
                                     This option overrides the 'UseColor' option in
                                     .clang-tidy file, if any.
     --verify-config                -
                                      Check the config files to ensure each check and
                                      option is recognized.
Configuration files:
     will be applied on top of the parent one. If any configuration options have
     a corresponding command-line option, command-line option takes precedence.
     The effective configuration can be inspected using -dump-config:
 
       $ clang-tidy -dump-config
       ---
       Checks:              '-*,some-check'
       WarningsAsErrors:    ''
+      HeaderFileExtensions:         ['', 'h','hh','hpp','hxx']
+      ImplementationFileExtensions: ['c','cc','cpp','cxx']
       HeaderFilterRegex:   ''
       FormatStyle:         none
       InheritParentConfig: true
       User:                user
       CheckOptions:
         some-check.SomeOption: 'some value'
       ...
 

clang-tools-extra/test/clang-tidy/infrastructure/verify-config.cpp

 // RUN: clang-tidy -verify-config --config='' | FileCheck %s -check-prefix=CHECK-VERIFY-OK
 // CHECK-VERIFY-OK: No config errors detected.
 
 // RUN: not clang-tidy -verify-config \
 // RUN: --checks='-*,bad*glob,llvm*,llvm-includeorder,my-made-up-check' --config='{Checks: "readability-else-after-ret", \
+// RUN: HeaderFileExtensions: ["h", "hh", "hpp"], \
+// RUN: ImplementationFileExtensions: ["c", "cc", "hpp"], \
 // RUN: CheckOptions: [{key: "IgnoreMacros", value: "true"}, \
 // RUN:                {key: "StriceMode", value: "true"}, \
 // RUN:                {key: modernize-lop-convert.UseCxx20ReverseRanges, value: true} \
 // RUN:               ]}' 2>&1 | FileCheck %s \
 // RUN: -check-prefix=CHECK-VERIFY -implicit-check-not='{{warning|error}}:'
 
 // CHECK-VERIFY-DAG: command-line option '-config': warning: unknown check 'readability-else-after-ret'; did you mean 'readability-else-after-return' [-verify-config]
 // CHECK-VERIFY-DAG: command-line option '-config': warning: unknown check option 'modernize-lop-convert.UseCxx20ReverseRanges'; did you mean 'modernize-loop-convert.UseCxx20ReverseRanges' [-verify-config]
 // CHECK-VERIFY-DAG: command-line option '-config': warning: unknown check option 'StriceMode'; did you mean 'StrictMode' [-verify-config]
+// CHECK-VERIFY-DAG: command-line option '-config': warning: HeaderFileExtension 'hpp' is the same as ImplementationFileExtension 'hpp' [-verify-config]
 // CHECK-VERIFY: command-line option '-checks': warning: check glob 'bad*glob' doesn't match any known check [-verify-config]
 // CHECK-VERIFY: command-line option '-checks': warning: unknown check 'llvm-includeorder'; did you mean 'llvm-include-order' [-verify-config]
 // CHECK-VERIFY: command-line option '-checks': warning: unknown check 'my-made-up-check' [-verify-config]

clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp

TEST(ParseLineFilter, ValidFilter) {
   EXPECT_EQ("file3.cc", Options.LineFilter[2].Name);
   EXPECT_EQ(1u, Options.LineFilter[2].LineRanges.size());
   EXPECT_EQ(100u, Options.LineFilter[2].LineRanges[0].first);
   EXPECT_EQ(1000u, Options.LineFilter[2].LineRanges[0].second);
 }
 
 TEST(ParseConfiguration, ValidConfiguration) {
   llvm::ErrorOr<ClangTidyOptions> Options =
-      parseConfiguration(llvm::MemoryBufferRef("Checks: \"-*,misc-*\"\n"
-                                               "HeaderFilterRegex: \".*\"\n"
-                                               "AnalyzeTemporaryDtors: true\n"
-                                               "User: some.user",
-                                               "Options"));
+      parseConfiguration(llvm::MemoryBufferRef(
+          "Checks: \"-*,misc-*\"\n"
+          "HeaderFileExtensions: [\"\",\"h\",\"hh\",\"hpp\",\"hxx\"]\n"
+          "ImplementationFileExtensions: [\"c\",\"cc\",\"cpp\",\"cxx\"]\n"
   EXPECT_TRUE(!!Options);
   EXPECT_EQ("-*,misc-*", *Options->Checks);
+  EXPECT_EQ(std::vector<std::string>({"", "h", "hh", "hpp", "hxx"}),
+            *Options->HeaderFileExtensions);
+  EXPECT_EQ(std::vector<std::string>({"c", "cc", "cpp", "cxx"}),
+            *Options->ImplementationFileExtensions);
   EXPECT_EQ(".*", *Options->HeaderFilterRegex);
   EXPECT_EQ("some.user", *Options->User);
 }
 
 TEST(ParseConfiguration, ChecksSeparatedByNewlines) {
   auto MemoryBuffer = llvm::MemoryBufferRef("Checks: |\n"
                                             "  -*,misc-*\n"
                                             "  llvm-*\n"
                                             "  -clang-*,\n"
                                             "  google-*",
                                             "Options");
 
   auto Options = parseConfiguration(MemoryBuffer);
 
   EXPECT_TRUE(!!Options);
   EXPECT_EQ("-*,misc-*\nllvm-*\n-clang-*,\ngoogle-*\n", *Options->Checks);
 }
 
 TEST(ParseConfiguration, MergeConfigurations) {
   llvm::ErrorOr<ClangTidyOptions> Options1 =
       parseConfiguration(llvm::MemoryBufferRef(R"(
       Checks: "check1,check2"
+      HeaderFileExtensions: ["h","hh"]
+      ImplementationFileExtensions: ["c","cc"]
       HeaderFilterRegex: "filter1"
       AnalyzeTemporaryDtors: true
       User: user1
       ExtraArgs: ['arg1', 'arg2']
       ExtraArgsBefore: ['arg-before1', 'arg-before2']
       UseColor: false
   )",
                                                "Options1"));
   ASSERT_TRUE(!!Options1);
   llvm::ErrorOr<ClangTidyOptions> Options2 =
       parseConfiguration(llvm::MemoryBufferRef(R"(
       Checks: "check3,check4"
+      HeaderFileExtensions: ["hpp","hxx"]
+      ImplementationFileExtensions: ["cpp","cxx"]
       HeaderFilterRegex: "filter2"
       AnalyzeTemporaryDtors: false
       User: user2
       ExtraArgs: ['arg3', 'arg4']
       ExtraArgsBefore: ['arg-before3', 'arg-before4']
       UseColor: true
   )",
                                                "Options2"));
   ASSERT_TRUE(!!Options2);
   ClangTidyOptions Options = Options1->merge(*Options2, 0);
   EXPECT_EQ("check1,check2,check3,check4", *Options.Checks);
+  EXPECT_EQ(std::vector<std::string>({"hpp", "hxx"}),
+            *Options.HeaderFileExtensions);
+  EXPECT_EQ(std::vector<std::string>({"cpp", "cxx"}),
+            *Options.ImplementationFileExtensions);
   EXPECT_EQ("filter2", *Options.HeaderFilterRegex);
   EXPECT_EQ("user2", *Options.User);
   ASSERT_TRUE(Options.ExtraArgs.has_value());
   EXPECT_EQ("arg1,arg2,arg3,arg4", llvm::join(Options.ExtraArgs->begin(),
                                               Options.ExtraArgs->end(), ","));
   ASSERT_TRUE(Options.ExtraArgsBefore.has_value());
   EXPECT_EQ("arg-before1,arg-before2,arg-before3,arg-before4",
             llvm::join(Options.ExtraArgsBefore->begin(),