[clang-tidy] Generalize HeaderFileExtensions.{h,cpp}. NFC

[jroelofs]

Summary

Splitting this out from https://reviews.llvm.org/D74669

[jroelofs]

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

14

this belongs in the other patch.

[aaron.ballman]

LGTM!

[jroelofs]

https://github.com/llvm/llvm-project/commit/3486cc014b208df3897cf5656db0d0fdeae26d6b

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/HeaderFileExtensionsUtils.h"
+#include "../utils/FileExtensionsUtils.h"
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 /// Finds dynamically initialized static variables in header files.
 ///
 /// The check supports these options:
 ///   - `HeaderFileExtensions`: a comma-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);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const std::string RawStringHeaderFileExtensions;
-  utils::HeaderFileExtensionsSet HeaderFileExtensions;
+  utils::FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_DYNAMIC_STATIC_INITIALIZERS_CHECK_H

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

AST_MATCHER(clang::VarDecl, hasConstantDeclaration) {
   return false;
 }
 
 DynamicStaticInitializersCheck::DynamicStaticInitializersCheck(StringRef Name,
                                                                ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
         "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
-  if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
-                                        HeaderFileExtensions, ',')) {
+  if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
     llvm::errs() << "Invalid header file extension: "
                  << RawStringHeaderFileExtensions << "\n";
   }
 }
 
 void DynamicStaticInitializersCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);

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

 //===--- GlobalNamesInHeadersCheck.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_GOOGLE_GLOBALNAMESINHEADERSCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GLOBALNAMESINHEADERSCHECK_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/HeaderFileExtensionsUtils.h"
+#include "../utils/FileExtensionsUtils.h"
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace readability {
 
 /// Flag global namespace pollution in header files.
 /// Right now it only triggers on using declarations and directives.
 ///
 /// The check supports these options:
 ///   - `HeaderFileExtensions`: a comma-separated list of filename extensions
 ///     of header files (the filename extensions should not contain "." prefix).
 ///     "h" by default.
 ///     For extension-less header files, using an empty string or leaving an
 ///     empty string between "," if there are other filename extensions.
 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 std::string RawStringHeaderFileExtensions;
-  utils::HeaderFileExtensionsSet HeaderFileExtensions;
+  utils::FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace readability
 } // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GLOBALNAMESINHEADERSCHECK_H

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

 namespace google {
 namespace readability {
 
 GlobalNamesInHeadersCheck::GlobalNamesInHeadersCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
           "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
-  if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
-                                        HeaderFileExtensions, ',')) {
+  if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
     llvm::errs() << "Invalid header file extension: "
                  << RawStringHeaderFileExtensions << "\n";
   }
 }
 
 void GlobalNamesInHeadersCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);

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

 //===--- UnnamedNamespaceInHeaderCheck.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_GOOGLE_UNNAMEDNAMESPACEINHEADERCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_UNNAMEDNAMESPACEINHEADERCHECK_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/HeaderFileExtensionsUtils.h"
+#include "../utils/FileExtensionsUtils.h"
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace build {
 
 /// Finds anonymous namespaces in headers.
 ///

 public:
   UnnamedNamespaceInHeaderCheck(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 std::string RawStringHeaderFileExtensions;
-  utils::HeaderFileExtensionsSet HeaderFileExtensions;
+  utils::FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace build
 } // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_UNNAMEDNAMESPACEINHEADERCHECK_H

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

 namespace google {
 namespace build {
 
 UnnamedNamespaceInHeaderCheck::UnnamedNamespaceInHeaderCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
           "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
-  if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
-                                        HeaderFileExtensions, ',')) {
+  if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
     llvm::errs() << "Invalid header file extension: "
                  << RawStringHeaderFileExtensions << "\n";
   }
 }
 
 void UnnamedNamespaceInHeaderCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);

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

 //===--- DefinitionsInHeadersCheck.h - clang-tidy----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONS_IN_HEADERS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONS_IN_HEADERS_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/HeaderFileExtensionsUtils.h"
+#include "../utils/FileExtensionsUtils.h"
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 /// Finds non-extern non-inline function and variable definitions in header
 /// files, which can lead to potential ODR violations.
 ///
public:
   DefinitionsInHeadersCheck(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 bool UseHeaderFileExtension;
   const std::string RawStringHeaderFileExtensions;
-  utils::HeaderFileExtensionsSet HeaderFileExtensions;
+  utils::FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONS_IN_HEADERS_H

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 namespace {
 
-AST_MATCHER_P(NamedDecl, usesHeaderFileExtension,
-              utils::HeaderFileExtensionsSet, HeaderFileExtensions) {
+AST_MATCHER_P(NamedDecl, usesHeaderFileExtension, utils::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())) {
-  if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
-                                        HeaderFileExtensions, ',')) {
+  if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
     // FIXME: Find a more suitable way to handle invalid configuration
     // options.
     llvm::errs() << "Invalid header file extension: "
                  << RawStringHeaderFileExtensions << "\n";
   }
 }
 
 void DefinitionsInHeadersCheck::storeOptions(

clang-tools-extra/clang-tidy/utils/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyUtils
   ASTUtils.cpp
   DeclRefExprUtils.cpp
   ExceptionAnalyzer.cpp
   ExprSequence.cpp
+  FileExtensionsUtils.cpp
   FixItHintUtils.cpp
-  HeaderFileExtensionsUtils.cpp
   HeaderGuard.cpp
   IncludeInserter.cpp
   IncludeSorter.cpp
   LexerUtils.cpp
   NamespaceAliaser.cpp
   OptionsUtils.cpp
   RenamerClangTidyCheck.cpp
   TransformerClangTidyCheck.cpp

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

-//===--- HeaderFileExtensionsUtils.h - clang-tidy----------------*- C++ -*-===//
+//===--- 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_HEADER_FILE_EXTENSIONS_UTILS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADER_FILE_EXTENSIONS_UTILS_H
 
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
-typedef llvm::SmallSet<llvm::StringRef, 5> HeaderFileExtensionsSet;
+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 HeaderFileExtensionsSet &HeaderFileExtensions);
+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 HeaderFileExtensionsSet &HeaderFileExtensions);
+bool isPresumedLocInHeaderFile(SourceLocation Loc, SourceManager &SM,
+                               const FileExtensionsSet &HeaderFileExtensions);
 
 /// Checks whether spelling location of \p Loc is in header file.
-bool isSpellingLocInHeaderFile(
-    SourceLocation Loc, SourceManager &SM,
-    const HeaderFileExtensionsSet &HeaderFileExtensions);
+bool isSpellingLocInHeaderFile(SourceLocation Loc, SourceManager &SM,
+                               const FileExtensionsSet &HeaderFileExtensions);
 
 /// Returns recommended default value for the list of header file
 /// extensions.
 inline StringRef defaultHeaderFileExtensions() { return ",h,hh,hpp,hxx"; }
 
 /// Parses header file extensions from a semicolon-separated list.
-bool parseHeaderFileExtensions(StringRef AllHeaderFileExtensions,
-                               HeaderFileExtensionsSet &HeaderFileExtensions,
-                               char delimiter);
-
-/// Decides whether a file has a header file extension.
-bool isHeaderFileExtension(StringRef FileName,
-                           const HeaderFileExtensionsSet &HeaderFileExtensions);
+bool parseFileExtensions(StringRef AllFileExtensions,
+                         FileExtensionsSet &FileExtensions, char Delimiter);
+
+/// Decides whether a file has one of the specified file extensions.
+bool isFileExtension(StringRef FileName,
+                     const FileExtensionsSet &FileExtensions);
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADER_FILE_EXTENSIONS_UTILS_H

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

+//===--- FileExtensionsUtils.cpp - 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "FileExtensionsUtils.h"
+#include "clang/Basic/CharInfo.h"
+#include "llvm/Support/Path.h"
+
+namespace clang {
+namespace tidy {
+namespace utils {
+
+bool isExpansionLocInHeaderFile(SourceLocation Loc, const SourceManager &SM,
+                                const FileExtensionsSet &HeaderFileExtensions) {
+  SourceLocation ExpansionLoc = SM.getExpansionLoc(Loc);
+  return isFileExtension(SM.getFilename(ExpansionLoc), HeaderFileExtensions);
+}
+
+bool isPresumedLocInHeaderFile(SourceLocation Loc, SourceManager &SM,
+                               const FileExtensionsSet &HeaderFileExtensions) {
+  PresumedLoc PresumedLocation = SM.getPresumedLoc(Loc);
+  return isFileExtension(PresumedLocation.getFilename(), HeaderFileExtensions);
+}
+
+bool isSpellingLocInHeaderFile(SourceLocation Loc, SourceManager &SM,
+                               const FileExtensionsSet &HeaderFileExtensions) {
+  SourceLocation SpellingLoc = SM.getSpellingLoc(Loc);
+  return isFileExtension(SM.getFilename(SpellingLoc), HeaderFileExtensions);
+}
+
+bool parseFileExtensions(StringRef AllFileExtensions,
+                         FileExtensionsSet &FileExtensions, char Delimiter) {
+  SmallVector<StringRef, 5> Suffixes;
+  AllFileExtensions.split(Suffixes, Delimiter);
+  FileExtensions.clear();
+  for (StringRef Suffix : Suffixes) {
+    StringRef Extension = Suffix.trim();
+    if (!llvm::all_of(Extension, isAlphanumeric))
+      return false;
+    FileExtensions.insert(Extension);
+  }
+  return true;
+}
+
+bool isFileExtension(StringRef FileName,
+                     const FileExtensionsSet &FileExtensions) {
+  StringRef extension = llvm::sys::path::extension(FileName);
+  if (extension.empty())
+    return false;
+  // Skip "." prefix.
+  return FileExtensions.count(extension.substr(1)) > 0;
+}
+
+} // namespace utils
+} // namespace tidy
+} // namespace clang

clang-tools-extra/clang-tidy/utils/HeaderFileExtensionsUtils.cpp

-//===--- HeaderFileExtensionsUtils.cpp - 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "HeaderFileExtensionsUtils.h"
-#include "clang/Basic/CharInfo.h"
-#include "llvm/Support/Path.h"
-
-namespace clang {
-namespace tidy {
-namespace utils {
-
-bool isExpansionLocInHeaderFile(
-    SourceLocation Loc, const SourceManager &SM,
-    const HeaderFileExtensionsSet &HeaderFileExtensions) {
-  SourceLocation ExpansionLoc = SM.getExpansionLoc(Loc);
-  return isHeaderFileExtension(SM.getFilename(ExpansionLoc),
-                               HeaderFileExtensions);
-}
-
-bool isPresumedLocInHeaderFile(
-    SourceLocation Loc, SourceManager &SM,
-    const HeaderFileExtensionsSet &HeaderFileExtensions) {
-  PresumedLoc PresumedLocation = SM.getPresumedLoc(Loc);
-  return isHeaderFileExtension(PresumedLocation.getFilename(),
-                               HeaderFileExtensions);
-}
-
-bool isSpellingLocInHeaderFile(
-    SourceLocation Loc, SourceManager &SM,
-    const HeaderFileExtensionsSet &HeaderFileExtensions) {
-  SourceLocation SpellingLoc = SM.getSpellingLoc(Loc);
-  return isHeaderFileExtension(SM.getFilename(SpellingLoc),
-                               HeaderFileExtensions);
-}
-
-bool parseHeaderFileExtensions(StringRef AllHeaderFileExtensions,
-                               HeaderFileExtensionsSet &HeaderFileExtensions,
-                               char delimiter) {
-  SmallVector<StringRef, 5> Suffixes;
-  AllHeaderFileExtensions.split(Suffixes, delimiter);
-  HeaderFileExtensions.clear();
-  for (StringRef Suffix : Suffixes) {
-    StringRef Extension = Suffix.trim();
-    for (StringRef::const_iterator it = Extension.begin();
-         it != Extension.end(); ++it) {
-      if (!isAlphanumeric(*it))
-        return false;
-    }
-    HeaderFileExtensions.insert(Extension);
-  }
-  return true;
-}
-
-bool isHeaderFileExtension(
-    StringRef FileName, const HeaderFileExtensionsSet &HeaderFileExtensions) {
-  StringRef extension = llvm::sys::path::extension(FileName);
-  if (extension.empty())
-    return false;
-  // Skip "." prefix.
-  return HeaderFileExtensions.count(extension.substr(1)) > 0;
-}
-
-} // namespace utils
-} // namespace tidy
-} // namespace clang

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

 //===--- HeaderGuard.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_HEADERGUARD_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADERGUARD_H
 
 #include "../ClangTidy.h"
-#include "../utils/HeaderFileExtensionsUtils.h"
+#include "../utils/FileExtensionsUtils.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
 /// Finds and fixes header guards.
 /// The check supports these options:
 ///   - `HeaderFileExtensions`: a comma-separated list of filename 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::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
-                                     HeaderFileExtensions, ',');
+    utils::parseFileExtensions(RawStringHeaderFileExtensions,
   }
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
 
   /// Returns ``true`` if the check should suggest inserting a trailing comment
   /// on the ``#endif`` of the header guard. It will use the same name as
   /// returned by ``HeaderGuardCheck::getHeaderGuard``.
   virtual bool shouldSuggestEndifComment(StringRef Filename);
   /// Returns ``true`` if the check should suggest changing an existing header
   /// guard to the string returned by ``HeaderGuardCheck::getHeaderGuard``.
   virtual bool shouldFixHeaderGuard(StringRef Filename);
   /// Returns ``true`` if the check should add a header guard to the file
   /// if it has none.
   virtual bool shouldSuggestToAddHeaderGuard(StringRef Filename);
   /// Returns a replacement for the ``#endif`` line with a comment mentioning
   /// \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::HeaderFileExtensionsSet HeaderFileExtensions;
+  utils::FileExtensionsSet HeaderFileExtensions;
 };
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADERGUARD_H

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

 
 void HeaderGuardCheck::registerPPCallbacks(const SourceManager &SM,
                                            Preprocessor *PP,
                                            Preprocessor *ModuleExpanderPP) {
   PP->addPPCallbacks(std::make_unique<HeaderGuardPPCallbacks>(PP, this));
 }
 
 bool HeaderGuardCheck::shouldSuggestEndifComment(StringRef FileName) {
-  return utils::isHeaderFileExtension(FileName, HeaderFileExtensions);
+  return utils::isFileExtension(FileName, HeaderFileExtensions);
 }
 
 bool HeaderGuardCheck::shouldFixHeaderGuard(StringRef FileName) { return true; }
 
 bool HeaderGuardCheck::shouldSuggestToAddHeaderGuard(StringRef FileName) {
-  return utils::isHeaderFileExtension(FileName, HeaderFileExtensions);
+  return utils::isFileExtension(FileName, HeaderFileExtensions);
 }
 
 std::string HeaderGuardCheck::formatEndIf(StringRef HeaderGuard) {
   return "endif // " + HeaderGuard.str();
 }
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang