[clang-tidy][NFC] Split up some headers

[njames93]

Summary

Extract the ClangTidyOptionsProvider and ClangTidyContext into their own headers.
The main purpose of this change is to reduce Dependancies in ClangTidyCheck.

[Eugene.Zelenko]

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

9

Should header guard just renamed?

190

Please add newline.

278

Should header guard just renamed?

[njames93]

Fix clang-tidy lint and comments.

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

 //===--- ClangTidy.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_CLANGTIDY_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDY_H
 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
+#include "llvm/Support/VirtualFileSystem.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {
 class raw_ostream;
 } // namespace llvm
 
 namespace clang {

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

 ///  This tool uses the Clang Tooling infrastructure, see
 ///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 ///  for details on setting it up with LLVM source tree.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidy.h"
 #include "ClangTidyCheck.h"
+#include "ClangTidyContext.h"
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyModuleRegistry.h"
+#include "ClangTidyOptionsProvider.h"
 #include "ClangTidyProfiling.h"
 #include "ExpandModularHeadersPPCallbacks.h"
 #include "clang-tidy-config.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/ASTConsumers.h"
 #include "clang/Frontend/CompilerInstance.h"

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

 //===--- ClangTidyCheck.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_CLANGTIDYCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYCHECK_H
 
-#include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/Diagnostic.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Error.h"
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace clang {
 
 class CompilerInstance;
 class SourceManager;
 
 namespace tidy {
 
+class ClangTidyContext;
+
 /// This class should be specialized by any enum type that needs to be converted
 /// to and from an \ref llvm::StringRef.
 template <class T> struct OptionEnumMapping {
   // Specializations of this struct must implement this function.
   static ArrayRef<std::pair<T, StringRef>> getEnumMapping() = delete;
 };
 
 template <typename T> class OptionError : public llvm::ErrorInfo<T> {
private:
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
   StringRef getID() const override { return CheckName; }
   std::string CheckName;
   ClangTidyContext *Context;
 
 protected:
   OptionsView Options;
   /// Returns the main file name of the current translation unit.
-  StringRef getCurrentMainFile() const { return Context->getCurrentFile(); }
+  StringRef getCurrentMainFile() const;
   /// Returns the language options from the context.
-  const LangOptions &getLangOpts() const { return Context->getLangOpts(); }
+  const LangOptions &getLangOpts() const;
 };
 
 /// 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, returns
 /// a ``MissingOptionError``. If the corresponding key can't be parsed as
 /// a bool, return an ``UnparseableIntegerOptionError``.

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

 //===--- ClangTidyCheck.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 "ClangTidyCheck.h"
+#include "ClangTidyContext.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/YAMLParser.h"
 
 namespace clang {
 namespace tidy {
 
ClangTidyCheck::OptionsView::getOptionalLocalOrGlobal<std::string>(
     StringRef LocalName) const {
   if (auto ValueOr = getLocalOrGlobal(LocalName))
     return *ValueOr;
   else
     consumeError(ValueOr.takeError());
   return llvm::None;
 }
 
+llvm::StringRef ClangTidyCheck::getCurrentMainFile() const {
+  return Context->getCurrentFile();
+}
+const LangOptions &ClangTidyCheck::getLangOpts() const {
+  return Context->getLangOpts();
+}
 } // namespace tidy
 } // namespace clang

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

-//===--- ClangTidyDiagnosticConsumer.h - clang-tidy -------------*- C++ -*-===//
+//===--- ClangTidyContext.h - clang-tidy ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
-
 #include "ClangTidyOptions.h"
 #include "ClangTidyProfiling.h"
 #include "clang/Basic/Diagnostic.h"
-#include "clang/Tooling/Core/Diagnostic.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/Support/Regex.h"
+#include <memory>
+#include <string>
+#include <utility>
 
 namespace clang {
-
 class ASTContext;
-class CompilerInstance;
-class SourceManager;
-namespace ast_matchers {
-class MatchFinder;
-}
-namespace tooling {
-class CompilationDatabase;
-}
-
 namespace tidy {
 
-/// A detected error complete with information to display diagnostic and
-/// automatic fix.
-///
-/// This is used as an intermediate format to transport Diagnostics without a
-/// dependency on a SourceManager.
-///
-/// FIXME: Make Diagnostics flexible enough to support this directly.
-struct ClangTidyError : tooling::Diagnostic {
-  ClangTidyError(StringRef CheckName, Level DiagLevel, StringRef BuildDirectory,
-                 bool IsWarningAsError);
-
-  bool IsWarningAsError;
-  std::vector<std::string> EnabledDiagnosticAliases;
-};
+class ClangTidyOptionsProvider;
 
 /// Contains displayed and ignored diagnostic counters for a ClangTidy
 /// run.
 struct ClangTidyStats {
   ClangTidyStats()
       : ErrorsDisplayed(0), ErrorsIgnoredCheckFilter(0), ErrorsIgnoredNOLINT(0),
         ErrorsIgnoredNonUserCode(0), ErrorsIgnoredLineFilter(0) {}
 
private:
   std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
 
   std::string CurrentFile;
   ClangTidyOptions CurrentOptions;
   class CachedGlobList;
   std::unique_ptr<CachedGlobList> CheckFilter;
   std::unique_ptr<CachedGlobList> WarningAsErrorFilter;
 
   LangOptions LangOpts;
 
   ClangTidyStats Stats;
 
   std::string CurrentBuildDirectory;
 
   llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
 
   bool Profile;
   std::string ProfilePrefix;
 
   bool AllowEnablingAnalyzerAlphaCheckers;
 };
-
-/// Check whether a given diagnostic should be suppressed due to the presence
-/// of a "NOLINT" suppression comment.
-/// This is exposed so that other tools that present clang-tidy diagnostics
-/// (such as clangd) can respect the same suppression rules as clang-tidy.
-/// This does not handle suppression of notes following a suppressed diagnostic;
-/// that is left to the caller is it requires maintaining state in between calls
-/// to this function.
-/// If `AllowIO` is false, the function does not attempt to read source files
-/// from disk which are not already mapped into memory; such files are treated
-/// as not containing a suppression comment.
-bool shouldSuppressDiagnostic(DiagnosticsEngine::Level DiagLevel,
-                              const Diagnostic &Info, ClangTidyContext &Context,
-                              bool AllowIO = true);
-
-/// A diagnostic consumer that turns each \c Diagnostic into a
-/// \c SourceManager-independent \c ClangTidyError.
-//
-// FIXME: If we move away from unit-tests, this can be moved to a private
-// implementation file.
-class ClangTidyDiagnosticConsumer : public DiagnosticConsumer {
-public:
-  ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx,
-                              DiagnosticsEngine *ExternalDiagEngine = nullptr,
-                              bool RemoveIncompatibleErrors = true);
-
-  // FIXME: The concept of converting between FixItHints and Replacements is
-  // more generic and should be pulled out into a more useful Diagnostics
-  // library.
-  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
-                        const Diagnostic &Info) override;
-
-  // Retrieve the diagnostics that were captured.
-  std::vector<ClangTidyError> take();
-
-private:
-  void finalizeLastError();
-  void removeIncompatibleErrors();
-  void removeDuplicatedDiagnosticsOfAliasCheckers();
-
-  /// Returns the \c HeaderFilter constructed for the options set in the
-  /// context.
-  llvm::Regex *getHeaderFilter();
-
-  /// Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
-  /// according to the diagnostic \p Location.
-  void checkFilters(SourceLocation Location, const SourceManager &Sources);
-  bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
-
-  void forwardDiagnostic(const Diagnostic &Info);
-
-  ClangTidyContext &Context;
-  DiagnosticsEngine *ExternalDiagEngine;
-  bool RemoveIncompatibleErrors;
-  std::vector<ClangTidyError> Errors;
-  std::unique_ptr<llvm::Regex> HeaderFilter;
-  bool LastErrorRelatesToUserCode;
-  bool LastErrorPassesLineFilter;
-  bool LastErrorWasIgnored;
-};
-
-} // end namespace tidy
-} // end namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
+} // namespace tidy
+} // namespace clang

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

 //===--- ClangTidyDiagnosticConsumer.h - clang-tidy -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
 
-#include "ClangTidyOptions.h"
 #include "ClangTidyProfiling.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Tooling/Core/Diagnostic.h"
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Regex.h"
 
 namespace clang {
 
 class ASTContext;
 class CompilerInstance;
 class SourceManager;
 namespace ast_matchers {
 class MatchFinder;
 }
 namespace tooling {
 class CompilationDatabase;
 }
 
 namespace tidy {
 
+class ClangTidyContext;
+
 /// A detected error complete with information to display diagnostic and
 /// automatic fix.
 ///
 /// This is used as an intermediate format to transport Diagnostics without a
 /// dependency on a SourceManager.
 ///
 /// FIXME: Make Diagnostics flexible enough to support this directly.
 struct ClangTidyError : tooling::Diagnostic {
   ClangTidyError(StringRef CheckName, Level DiagLevel, StringRef BuildDirectory,
                  bool IsWarningAsError);
 
   bool IsWarningAsError;
   std::vector<std::string> EnabledDiagnosticAliases;
 };
 
-/// Contains displayed and ignored diagnostic counters for a ClangTidy
-/// run.
-struct ClangTidyStats {
-  ClangTidyStats()
-      : ErrorsDisplayed(0), ErrorsIgnoredCheckFilter(0), ErrorsIgnoredNOLINT(0),
-        ErrorsIgnoredNonUserCode(0), ErrorsIgnoredLineFilter(0) {}
-
-  unsigned ErrorsDisplayed;
-  unsigned ErrorsIgnoredCheckFilter;
-  unsigned ErrorsIgnoredNOLINT;
-  unsigned ErrorsIgnoredNonUserCode;
-  unsigned ErrorsIgnoredLineFilter;
-
-  unsigned errorsIgnored() const {
-    return ErrorsIgnoredNOLINT + ErrorsIgnoredCheckFilter +
-           ErrorsIgnoredNonUserCode + ErrorsIgnoredLineFilter;
-  }
-};
-
-/// Every \c ClangTidyCheck reports errors through a \c DiagnosticsEngine
-/// provided by this context.
-///
-/// A \c ClangTidyCheck always has access to the active context to report
-/// warnings like:
-/// \code
-/// Context->Diag(Loc, "Single-argument constructors must be explicit")
-///     << FixItHint::CreateInsertion(Loc, "explicit ");
-/// \endcode
-class ClangTidyContext {
-public:
-  /// Initializes \c ClangTidyContext instance.
-  ClangTidyContext(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
-                   bool AllowEnablingAnalyzerAlphaCheckers = false);
-  /// Sets the DiagnosticsEngine that diag() will emit diagnostics to.
-  // FIXME: this is required initialization, and should be a constructor param.
-  // Fix the context -> diag engine -> consumer -> context initialization cycle.
-  void setDiagnosticsEngine(DiagnosticsEngine *DiagEngine) {
-    this->DiagEngine = DiagEngine;
-  }
-
-  ~ClangTidyContext();
-
-  /// Report any errors detected using this method.
-  ///
-  /// This is still under heavy development and will likely change towards using
-  /// tablegen'd diagnostic IDs.
-  /// FIXME: Figure out a way to manage ID spaces.
-  DiagnosticBuilder diag(StringRef CheckName, SourceLocation Loc,
-                         StringRef Message,
-                         DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
-
-  DiagnosticBuilder diag(StringRef CheckName, StringRef Message,
-                         DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
-
-  /// Report any errors to do with reading the configuration using this method.
-  DiagnosticBuilder
-  configurationDiag(StringRef Message,
-                    DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
-
-  /// Sets the \c SourceManager of the used \c DiagnosticsEngine.
-  ///
-  /// This is called from the \c ClangTidyCheck base class.
-  void setSourceManager(SourceManager *SourceMgr);
-
-  /// Should be called when starting to process new translation unit.
-  void setCurrentFile(StringRef File);
-
-  /// Returns the main file name of the current translation unit.
-  StringRef getCurrentFile() const { return CurrentFile; }
-
-  /// Sets ASTContext for the current translation unit.
-  void setASTContext(ASTContext *Context);
-
-  /// Gets the language options from the AST context.
-  const LangOptions &getLangOpts() const { return LangOpts; }
-
-  /// Returns the name of the clang-tidy check which produced this
-  /// diagnostic ID.
-  std::string getCheckName(unsigned DiagnosticID) const;
-
-  /// Returns \c true if the check is enabled for the \c CurrentFile.
-  ///
-  /// The \c CurrentFile can be changed using \c setCurrentFile.
-  bool isCheckEnabled(StringRef CheckName) const;
-
-  /// Returns \c true if the check should be upgraded to error for the
-  /// \c CurrentFile.
-  bool treatAsError(StringRef CheckName) const;
-
-  /// Returns global options.
-  const ClangTidyGlobalOptions &getGlobalOptions() const;
-
-  /// Returns options for \c CurrentFile.
-  ///
-  /// 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;
-
-  /// 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; }
-
-  /// Control storage of profile date.
-  void setProfileStoragePrefix(StringRef ProfilePrefix);
-  llvm::Optional<ClangTidyProfiling::StorageParams>
-  getProfileStorageParams() const;
-
-  /// Should be called when starting to process new translation unit.
-  void setCurrentBuildDirectory(StringRef BuildDirectory) {
-    CurrentBuildDirectory = std::string(BuildDirectory);
-  }
-
-  /// Returns build directory of the current translation unit.
-  const std::string &getCurrentBuildDirectory() {
-    return CurrentBuildDirectory;
-  }
-
-  /// If the experimental alpha checkers from the static analyzer can be
-  /// enabled.
-  bool canEnableAnalyzerAlphaCheckers() const {
-    return AllowEnablingAnalyzerAlphaCheckers;
-  }
-
-  using DiagLevelAndFormatString = std::pair<DiagnosticIDs::Level, std::string>;
-  DiagLevelAndFormatString getDiagLevelAndFormatString(unsigned DiagnosticID,
-                                                       SourceLocation Loc) {
-    return DiagLevelAndFormatString(
-        static_cast<DiagnosticIDs::Level>(
-            DiagEngine->getDiagnosticLevel(DiagnosticID, Loc)),
-        std::string(
-            DiagEngine->getDiagnosticIDs()->getDescription(DiagnosticID)));
-  }
-
-private:
-  // Writes to Stats.
-  friend class ClangTidyDiagnosticConsumer;
-
-  DiagnosticsEngine *DiagEngine;
-  std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
-
-  std::string CurrentFile;
-  ClangTidyOptions CurrentOptions;
-  class CachedGlobList;
-  std::unique_ptr<CachedGlobList> CheckFilter;
-  std::unique_ptr<CachedGlobList> WarningAsErrorFilter;
-
-  LangOptions LangOpts;
-
-  ClangTidyStats Stats;
-
-  std::string CurrentBuildDirectory;
-
-  llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
-
-  bool Profile;
-  std::string ProfilePrefix;
-
-  bool AllowEnablingAnalyzerAlphaCheckers;
-};
-
 /// Check whether a given diagnostic should be suppressed due to the presence
 /// of a "NOLINT" suppression comment.
 /// This is exposed so that other tools that present clang-tidy diagnostics
 /// (such as clangd) can respect the same suppression rules as clang-tidy.
 /// This does not handle suppression of notes following a suppressed diagnostic;
 /// that is left to the caller is it requires maintaining state in between calls
 /// to this function.
 /// If `AllowIO` is false, the function does not attempt to read source files

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

 ///
 ///  This tool uses the Clang Tooling infrastructure, see
 ///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 ///  for details on setting it up with LLVM source tree.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyDiagnosticConsumer.h"
+#include "ClangTidyContext.h"
 #include "ClangTidyOptions.h"
+#include "ClangTidyOptionsProvider.h"
 #include "GlobList.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/Attr.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/DiagnosticRenderer.h"

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

 //===--- tools/extra/clang-tidy/ClangTidyModule.cpp - Clang tidy tool -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 ///  \file Implements classes required to build clang-tidy modules.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyModule.h"
 #include "ClangTidyCheck.h"
+#include "ClangTidyContext.h"
 
 namespace clang {
 namespace tidy {
 
 void ClangTidyCheckFactories::registerCheckFactory(StringRef Name,
                                                    CheckFactory Factory) {
   Factories.insert_or_assign(Name, std::move(Factory));
 }

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

 //===--- ClangTidyOptions.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_CLANGTIDYOPTIONS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONS_H
 
-#include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/MemoryBufferRef.h"
-#include "llvm/Support/VirtualFileSystem.h"
-#include <functional>
+#include "llvm/Support/Compiler.h"
 #include <string>
-#include <system_error>
 #include <utility>
 #include <vector>
 
 namespace clang {
 namespace tidy {
 
 /// Contains a list of line ranges in a single file.
 struct FileFilter {
struct ClangTidyOptions {
   /// same logic as FileOptionsProvider. If false or missing, only this
   /// configuration file will be used.
   llvm::Optional<bool> InheritParentConfig;
 
   /// Use colors in diagnostics. If missing, it will be auto detected.
   llvm::Optional<bool> UseColor;
 };
 
-/// Abstract interface for retrieving various ClangTidy options.
-class ClangTidyOptionsProvider {
-public:
-  static const char OptionsSourceTypeDefaultBinary[];
-  static const char OptionsSourceTypeCheckCommandLineOption[];
-  static const char OptionsSourceTypeConfigCommandLineOption[];
-
-  virtual ~ClangTidyOptionsProvider() {}
-
-  /// Returns global options, which are independent of the file.
-  virtual const ClangTidyGlobalOptions &getGlobalOptions() = 0;
-
-  /// ClangTidyOptions and its source.
-  //
-  /// clang-tidy has 3 types of the sources in order of increasing priority:
-  ///    * clang-tidy binary.
-  ///    * '-config' commandline option or a specific configuration file. If the
-  ///       commandline option is specified, clang-tidy will ignore the
-  ///       configuration file.
-  ///    * '-checks' commandline option.
-  typedef std::pair<ClangTidyOptions, std::string> OptionsSource;
-
-  /// Returns an ordered vector of OptionsSources, in order of increasing
-  /// priority.
-  virtual std::vector<OptionsSource>
-  getRawOptions(llvm::StringRef FileName) = 0;
-
-  /// Returns options applying to a specific translation unit with the
-  /// specified \p FileName.
-  ClangTidyOptions getOptions(llvm::StringRef FileName);
-};
-
-/// Implementation of the \c ClangTidyOptionsProvider interface, which
-/// returns the same options for all files.
-class DefaultOptionsProvider : public ClangTidyOptionsProvider {
-public:
-  DefaultOptionsProvider(ClangTidyGlobalOptions GlobalOptions,
-                         ClangTidyOptions Options)
-      : GlobalOptions(std::move(GlobalOptions)),
-        DefaultOptions(std::move(Options)) {}
-  const ClangTidyGlobalOptions &getGlobalOptions() override {
-    return GlobalOptions;
-  }
-  std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override;
-
-private:
-  ClangTidyGlobalOptions GlobalOptions;
-  ClangTidyOptions DefaultOptions;
-};
-
-class FileOptionsBaseProvider : public DefaultOptionsProvider {
-protected:
-  // A pair of configuration file base name and a function parsing
-  // configuration from text in the corresponding format.
-  typedef std::pair<std::string, std::function<llvm::ErrorOr<ClangTidyOptions>(
-                                     llvm::MemoryBufferRef)>>
-      ConfigFileHandler;
-
-  /// Configuration file handlers listed in the order of priority.
-  ///
-  /// Custom configuration file formats can be supported by constructing the
-  /// list of handlers and passing it to the appropriate \c FileOptionsProvider
-  /// constructor. E.g. initialization of a \c FileOptionsProvider with support
-  /// of a custom configuration file format for files named ".my-tidy-config"
-  /// could look similar to this:
-  /// \code
-  /// FileOptionsProvider::ConfigFileHandlers ConfigHandlers;
-  /// ConfigHandlers.emplace_back(".my-tidy-config", parseMyConfigFormat);
-  /// ConfigHandlers.emplace_back(".clang-tidy", parseConfiguration);
-  /// return std::make_unique<FileOptionsProvider>(
-  ///     GlobalOptions, DefaultOptions, OverrideOptions, ConfigHandlers);
-  /// \endcode
-  ///
-  /// With the order of handlers shown above, the ".my-tidy-config" file would
-  /// take precedence over ".clang-tidy" if both reside in the same directory.
-  typedef std::vector<ConfigFileHandler> ConfigFileHandlers;
-
-  FileOptionsBaseProvider(ClangTidyGlobalOptions GlobalOptions,
-                          ClangTidyOptions DefaultOptions,
-                          ClangTidyOptions OverrideOptions,
-                          llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS);
-
-  FileOptionsBaseProvider(ClangTidyGlobalOptions GlobalOptions,
-                          ClangTidyOptions DefaultOptions,
-                          ClangTidyOptions OverrideOptions,
-                          ConfigFileHandlers ConfigHandlers);
-
-protected:
-  void addRawFileOptions(llvm::StringRef AbsolutePath,
-                         std::vector<OptionsSource> &CurOptions);
-
-  /// Try to read configuration files from \p Directory using registered
-  /// \c ConfigHandlers.
-  llvm::Optional<OptionsSource> tryReadConfigFile(llvm::StringRef Directory);
-
-  llvm::StringMap<OptionsSource> CachedOptions;
-  ClangTidyOptions OverrideOptions;
-  ConfigFileHandlers ConfigHandlers;
-  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS;
-};
-
-/// Implementation of ClangTidyOptions interface, which is used for
-/// '-config' command-line option.
-class ConfigOptionsProvider : public FileOptionsBaseProvider {
-public:
-  ConfigOptionsProvider(
-      ClangTidyGlobalOptions GlobalOptions, ClangTidyOptions DefaultOptions,
-      ClangTidyOptions ConfigOptions, ClangTidyOptions OverrideOptions,
-      llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = nullptr);
-  std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override;
-
-private:
-  ClangTidyOptions ConfigOptions;
-};
-
-/// Implementation of the \c ClangTidyOptionsProvider interface, which
-/// tries to find a configuration file in the closest parent directory of each
-/// source file.
-///
-/// By default, files named ".clang-tidy" will be considered, and the
-/// \c clang::tidy::parseConfiguration function will be used for parsing, but a
-/// custom set of configuration file names and parsing functions can be
-/// specified using the appropriate constructor.
-class FileOptionsProvider : public FileOptionsBaseProvider {
-public:
-  /// Initializes the \c FileOptionsProvider instance.
-  ///
-  /// \param GlobalOptions are just stored and returned to the caller of
-  /// \c getGlobalOptions.
-  ///
-  /// \param DefaultOptions are used for all settings not specified in a
-  /// configuration file.
-  ///
-  /// If any of the \param OverrideOptions fields are set, they will override
-  /// whatever options are read from the configuration file.
-  FileOptionsProvider(
-      ClangTidyGlobalOptions GlobalOptions, ClangTidyOptions DefaultOptions,
-      ClangTidyOptions OverrideOptions,
-      llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = nullptr);
-
-  /// Initializes the \c FileOptionsProvider instance with a custom set
-  /// of configuration file handlers.
-  ///
-  /// \param GlobalOptions are just stored and returned to the caller of
-  /// \c getGlobalOptions.
-  ///
-  /// \param DefaultOptions are used for all settings not specified in a
-  /// configuration file.
-  ///
-  /// If any of the \param OverrideOptions fields are set, they will override
-  /// whatever options are read from the configuration file.
-  ///
-  /// \param ConfigHandlers specifies a custom set of configuration file
-  /// handlers. Each handler is a pair of configuration file name and a function
-  /// that can parse configuration from this file type. The configuration files
-  /// in each directory are searched for in the order of appearance in
-  /// \p ConfigHandlers.
-  FileOptionsProvider(ClangTidyGlobalOptions GlobalOptions,
-                      ClangTidyOptions DefaultOptions,
-                      ClangTidyOptions OverrideOptions,
-                      ConfigFileHandlers ConfigHandlers);
-
-  std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override;
-};
-
-/// Parses LineFilter from JSON and stores it to the \p Options.
-std::error_code parseLineFilter(llvm::StringRef LineFilter,
-                                ClangTidyGlobalOptions &Options);
-
-/// Parses configuration from JSON and returns \c ClangTidyOptions or an
-/// error.
-llvm::ErrorOr<ClangTidyOptions>
-parseConfiguration(llvm::MemoryBufferRef Config);
-
-using DiagCallback = llvm::function_ref<void(const llvm::SMDiagnostic &)>;
-
-llvm::ErrorOr<ClangTidyOptions>
-parseConfigurationWithDiags(llvm::MemoryBufferRef Config, DiagCallback Handler);
-
-/// Serializes configuration to a YAML-encoded string.
-std::string configurationAsText(const ClangTidyOptions &Options);
-
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONS_H

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

 //===--- ClangTidyOptions.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 "ClangTidyOptions.h"
 #include "ClangTidyModuleRegistry.h"
+#include "ClangTidyOptionsProvider.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/YAMLTraits.h"

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

-//===--- ClangTidyOptions.h - clang-tidy ------------------------*- C++ -*-===//
+//===--- ClangTidyOptionsProvider.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_CLANGTIDYOPTIONS_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONS_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONSPROVIDER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONSPROVIDER_H
 
+#include "ClangTidyOptions.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/ErrorOr.h"
-#include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/VirtualFileSystem.h"
-#include <functional>
-#include <string>
-#include <system_error>
-#include <utility>
-#include <vector>
 
 namespace clang {
 namespace tidy {
-
-/// Contains a list of line ranges in a single file.
-struct FileFilter {
-  /// File name.
-  std::string Name;
-
-  /// LineRange is a pair<start, end> (inclusive).
-  typedef std::pair<unsigned, unsigned> LineRange;
-
-  /// A list of line ranges in this file, for which we show warnings.
-  std::vector<LineRange> LineRanges;
-};
-
-/// Global options. These options are neither stored nor read from
-/// configuration files.
-struct ClangTidyGlobalOptions {
-  /// Output warnings from certain line ranges of certain files only.
-  /// If empty, no warnings will be filtered.
-  std::vector<FileFilter> LineFilter;
-};
-
-/// Contains options for clang-tidy. These options may be read from
-/// configuration files, and may be different for different translation units.
-struct ClangTidyOptions {
-  /// These options are used for all settings that haven't been
-  /// overridden by the \c OptionsProvider.
-  ///
-  /// Allow no checks and no headers by default. This method initializes
-  /// check-specific options by calling \c ClangTidyModule::getModuleOptions()
-  /// of each registered \c ClangTidyModule.
-  static ClangTidyOptions getDefaults();
-
-  /// Overwrites all fields in here by the fields of \p Other that have a value.
-  /// \p Order specifies precedence of \p Other option.
-  ClangTidyOptions &mergeWith(const ClangTidyOptions &Other, unsigned Order);
-
-  /// Creates a new \c ClangTidyOptions instance combined from all fields
-  /// of this instance overridden by the fields of \p Other that have a value.
-  /// \p Order specifies precedence of \p Other option.
-  LLVM_NODISCARD ClangTidyOptions merge(const ClangTidyOptions &Other,
-                                        unsigned Order) const;
-
-  /// Checks filter.
-  llvm::Optional<std::string> Checks;
-
-  /// WarningsAsErrors filter.
-  llvm::Optional<std::string> WarningsAsErrors;
-
-  /// 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;
-
-  /// 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
-  ///     each source file;
-  ///   * '{inline-formatting-style-in-yaml-format}'.
-  ///
-  /// See clang-format documentation for more about configuring format style.
-  llvm::Optional<std::string> FormatStyle;
-
-  /// Specifies the name or e-mail of the user running clang-tidy.
-  ///
-  /// This option is used, for example, to place the correct user name in TODO()
-  /// comments in the relevant check.
-  llvm::Optional<std::string> User;
-
-  /// Helper structure for storing option value with priority of the value.
-  struct ClangTidyValue {
-    ClangTidyValue() : Value(), Priority(0) {}
-    ClangTidyValue(const char *Value) : Value(Value), Priority(0) {}
-    ClangTidyValue(llvm::StringRef Value, unsigned Priority = 0)
-        : Value(Value), Priority(Priority) {}
-
-    std::string Value;
-    /// Priority stores relative precedence of the value loaded from config
-    /// files to disambigute local vs global value from different levels.
-    unsigned Priority;
-  };
-  typedef std::pair<std::string, std::string> StringPair;
-  typedef llvm::StringMap<ClangTidyValue> OptionMap;
-
-  /// Key-value mapping used to store check-specific options.
-  OptionMap CheckOptions;
-
-  typedef std::vector<std::string> ArgList;
-
-  /// Add extra compilation arguments to the end of the list.
-  llvm::Optional<ArgList> ExtraArgs;
-
-  /// Add extra compilation arguments to the start of the list.
-  llvm::Optional<ArgList> ExtraArgsBefore;
-
-  /// Only used in the FileOptionsProvider and ConfigOptionsProvider. If true
-  /// and using a FileOptionsProvider, it will take a configuration file in the
-  /// parent directory (if any exists) and apply this config file on top of the
-  /// parent one. IF true and using a ConfigOptionsProvider, it will apply this
-  /// config on top of any configuation file it finds in the directory using the
-  /// same logic as FileOptionsProvider. If false or missing, only this
-  /// configuration file will be used.
-  llvm::Optional<bool> InheritParentConfig;
-
-  /// Use colors in diagnostics. If missing, it will be auto detected.
-  llvm::Optional<bool> UseColor;
-};
-
 /// Abstract interface for retrieving various ClangTidy options.
 class ClangTidyOptionsProvider {
 public:
   static const char OptionsSourceTypeDefaultBinary[];
   static const char OptionsSourceTypeCheckCommandLineOption[];
   static const char OptionsSourceTypeConfigCommandLineOption[];
 
   virtual ~ClangTidyOptionsProvider() {}

 
 using DiagCallback = llvm::function_ref<void(const llvm::SMDiagnostic &)>;
 
 llvm::ErrorOr<ClangTidyOptions>
 parseConfigurationWithDiags(llvm::MemoryBufferRef Config, DiagCallback Handler);
 
 /// Serializes configuration to a YAML-encoded string.
 std::string configurationAsText(const ClangTidyOptions &Options);
+} // namespace tidy
+} // namespace clang
 
-} // end namespace tidy
-} // end namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONS_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONSPROVIDER_H

clang-tools-extra/clang-tidy/cppcoreguidelines/PreferMemberInitializerCheck.cpp

 //===--- PreferMemberInitializerCheck.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 "PreferMemberInitializerCheck.h"
+#include "../ClangTidyContext.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {

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

 //===--- TodoCommentCheck.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 "TodoCommentCheck.h"
+#include "../ClangTidyContext.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Preprocessor.h"
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace readability {
 

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

 //===--- IdentifierNamingCheck.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 "IdentifierNamingCheck.h"
 
+#include "../ClangTidyContext.h"
 #include "../GlobList.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"

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

 ///  This tool uses the Clang Tooling infrastructure, see
 ///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 ///  for details on setting it up with LLVM source tree.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyMain.h"
 #include "../ClangTidy.h"
+#include "../ClangTidyContext.h"
 #include "../ClangTidyForceLinker.h"
+#include "../ClangTidyOptionsProvider.h"
 #include "../GlobList.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 

clang-tools-extra/clangd/Diagnostics.cpp

 //===--- Diagnostics.cpp -----------------------------------------*- 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 "Diagnostics.h"
-#include "../clang-tidy/ClangTidyDiagnosticConsumer.h"
+#include "../clang-tidy/ClangTidyContext.h"
 #include "Compiler.h"
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "support/Logger.h"
 #include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/FileManager.h"

clang-tools-extra/clangd/ParsedAST.cpp

 //===--- ParsedAST.cpp -------------------------------------------*- 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 "ParsedAST.h"
 #include "../clang-tidy/ClangTidyCheck.h"
+#include "../clang-tidy/ClangTidyContext.h"
 #include "../clang-tidy/ClangTidyDiagnosticConsumer.h"
 #include "../clang-tidy/ClangTidyModuleRegistry.h"
+#include "../clang-tidy/ClangTidyOptionsProvider.h"
 #include "AST.h"
 #include "Compiler.h"
 #include "Diagnostics.h"
 #include "Headers.h"
 #include "IncludeFixer.h"
 #include "Preamble.h"
 #include "SourceCode.h"
 #include "TidyProvider.h"

clang-tools-extra/clangd/TidyProvider.cpp

 //===--- TidyProvider.cpp - create options for running 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 "TidyProvider.h"
 #include "../clang-tidy/ClangTidyModuleRegistry.h"
+#include "../clang-tidy/ClangTidyOptionsProvider.h"
 #include "Config.h"
 #include "support/FileCache.h"
 #include "support/Logger.h"
 #include "support/ThreadsafeFS.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSet.h"

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

-#include "ClangTidyOptions.h"
 #include "ClangTidyCheck.h"
+#include "ClangTidyContext.h"
 #include "ClangTidyDiagnosticConsumer.h"
+#include "ClangTidyOptionsProvider.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Testing/Support/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace tidy {

clang-tools-extra/unittests/clang-tidy/ClangTidyTest.h

 //===--- ClangTidyTest.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_UNITTESTS_CLANG_TIDY_CLANGTIDYTEST_H
 #define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANG_TIDY_CLANGTIDYTEST_H
 
 #include "ClangTidy.h"
 #include "ClangTidyCheck.h"
+#include "ClangTidyContext.h"
 #include "ClangTidyDiagnosticConsumer.h"
+#include "ClangTidyOptionsProvider.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Path.h"

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

 //===---- ObjCModuleTest.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 "ClangTidyOptions.h"
+#include "ClangTidyOptionsProvider.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace tidy {
 namespace test {