[clang-tidy] Move IncludeInserter into ClangTidyContext

[njames93]

Summary

Following on from D117129, This changes fundamentally how IncludeInserter works.
Now each check that wants to create includes just calls registerIncludeInserter in their constructor.
This in turn enables a shared IncludeInserter in the ClangTidyContext.
Going this route means only 1 instance of IncludeInserter is needed and prevents different checks conflicting when they both try to create the same include.
Only using 1 instance also means there is only 1 possible IncludeStyle which is now sourced from global check options solely, rather that getting a local option for each check that wants to use it. This is a partially breaking change so warnings have been added for any old configs that try to use local options to set IncludeStyle.

[Eugene.Zelenko]

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

489

Please do not use auto, because type is not spelled explicitly in statement.

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

569

Ditto.

[njames93]

Update some includes

[LegalizeAdulthood]

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

434

Why not just Context.registerIncludeInserter(PP) and follow the Law of Demeter?

Let Context do the hasIncludeInserter() check itself.

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

220–238

Law of Demeter. Move this to ClangTidyContext and let it handle the details.

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

420

diag has visibility public. Any reason why these are visibility protected?

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

219

is this-> necessary here?

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

20

What's the guidance on what belongs in clang::tidy
and what belongs in clang::tidy::utils?

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

14

Since you introduced ArrayRef<StringRef> as a data type, I was expecting
the includes for those to be included instead of StringMap; are we really
using StringMap in this header?

"Include what you use" would seem to imply that we should be including:

• StringRef
• ArrayRef
• Optional
• FixItHint

clang-tools-extra/clangd/ParsedAST.cpp

432–433

Law of Demeter

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

71–72

Law of Demeter

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

259–289

Am I correct in thinking that these are now redundant tests
because IncludeInserterTest covers these cases?

[njames93]

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

220–238

Are you suggesting I create methods for createIncludeInsertion in the ClangTidyContext?

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

20

Well as the file moved out of utils, its no longer in the utils namespace.

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

14

IWYU should strictly be followed but in practice throughout clang/llvm it never really is.
We are actually using StringMap in this header.
All I really did here was using clangd's include information fix-its to make it compile.

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

259–289

This test is redundant as checks no longer look for a local IncludeStyle instead just reading the global IncludeStyle which is what the following test is checking for.

[njames93]

Address comments

[LegalizeAdulthood]

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

220–238

Yes, exactly. Delegate everything to the Context object, instead of
grabbing a piece of data (the include inserter) our of the Context
object and manipulating it.

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

128–131

Add doxygen comments, please

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

20

Yes, if you move the file out of utils then it shouldn't be in the
utils namespace. But why move the file in the first place?

IOW, what is the guideline for what files belong under utils
and what files belong under clang-tidy?

[njames93]

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

20

Utils is for utilities that checks can make use of, but aren't required for the base clang-tidy infra to work.
By having the Inserter as a dependancy for ClangTidyDiagnosticConsumer it is now required for clang-tidy infrastructure, hence it was moved out of utils.

[LegalizeAdulthood]

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

20

OK yeah, that's a good explanation, thanks!

[LegalizeAdulthood]

If the only thing holding this up is my comments about following the Law of Demeter, I don't think that should block submitting this change.

I don't feel strongly about it enough to block submission and the style guide doesn't say anything about it.

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

add_clang_library(clangTidy
   ClangTidy.cpp
   ClangTidyCheck.cpp
   ClangTidyModule.cpp
   ClangTidyDiagnosticConsumer.cpp
   ClangTidyOptions.cpp
   ClangTidyProfiling.cpp
   ExpandModularHeadersPPCallbacks.cpp
   GlobList.cpp
+  IncludeSorter.cpp
+  IncludeInserter.cpp
 
   DEPENDS
   ClangSACheckers
   omp_gen
   )
 
 clang_target_link_libraries(clangTidy
   PRIVATE

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

ClangTidyASTConsumerFactory::createASTConsumer(
 
   if (Context.getLangOpts().Modules && OverlayFS != nullptr) {
     auto ModuleExpander = std::make_unique<ExpandModularHeadersPPCallbacks>(
         &Compiler, OverlayFS);
     ModuleExpanderPP = ModuleExpander->getPreprocessor();
     PP->addPPCallbacks(std::move(ModuleExpander));
   }
 
+  if (Context.hasIncludeInserter())
+    Context.getIncludeInserter().registerPreprocessor(PP);
+
   for (auto &Check : Checks) {
     Check->registerMatchers(&*Finder);
     Check->registerPPCallbacks(*SM, PP, ModuleExpanderPP);
   }
 
   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
   if (!Checks.empty())
     Consumers.push_back(Finder->newASTConsumer());
#endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
   llvm::sort(CheckNames);
   return CheckNames;
 }
 
 ClangTidyOptions::OptionMap ClangTidyASTConsumerFactory::getCheckOptions() {
   ClangTidyOptions::OptionMap Options;
   std::vector<std::unique_ptr<ClangTidyCheck>> Checks =
       CheckFactories->createChecks(&Context);
+  if (Context.hasIncludeInserter()) {
+    auto Mapping = IncludeSorter::getStyleMapping();
+    auto Index = static_cast<unsigned>(Context.getIncludeInserter().getStyle());
+    assert(Index < Mapping.size());
+    Options["IncludeStyle"] = Mapping[Index];
+  }
   for (const auto &Check : Checks)
     Check->storeOptions(Options);
   return Options;
 }
 
 std::vector<std::string>
 getCheckNames(const ClangTidyOptions &Options,
               bool AllowEnablingAnalyzerAlphaCheckers) {

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

public:
   DiagnosticBuilder diag(StringRef Description,
                          DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
 
   /// Adds a diagnostic to report errors in the check's configuration.
   DiagnosticBuilder
   configurationDiag(StringRef Description,
                     DiagnosticIDs::Level Level = DiagnosticIDs::Warning) const;
 
   /// Should store all options supported by this check with their
   /// current values or default values for options that haven't been overridden.
   ///
   /// The check should use ``Options.store()`` to store each option it supports
   /// whether it has the default value or it has been overridden.
   virtual void storeOptions(ClangTidyOptions::OptionMap &Options) {}
 
   /// Provides access to the ``ClangTidyCheck`` options via check-local
   /// names.
   ///
   /// Methods of this class prepend ``CheckName + "."`` to translate check-local
   /// option names to global option names.

 
 private:
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
   StringRef getID() const override { return CheckName; }
   std::string CheckName;
   ClangTidyContext *Context;
 
 protected:
+  void registerIncludeInserter() {
+    Context->registerIncludeInserter(CheckName);
+  }
+
+  llvm::Optional<FixItHint> createMainFileIncludeInsertion(StringRef Include);
+  llvm::Optional<FixItHint> createIncludeInsertion(FileID File,
+                                                   StringRef Include);
   OptionsView Options;
   /// Returns the main file name of the current translation unit.
   StringRef getCurrentMainFile() const { return Context->getCurrentFile(); }
   /// Returns the language options from the context.
   const LangOptions &getLangOpts() const { return Context->getLangOpts(); }
 };
 
 /// Read a named option from the ``Context`` and parse it as a bool.

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

 }
 std::string
 ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName,
                                               StringRef Default) const {
   if (llvm::Optional<std::string> Val = getLocalOrGlobal(LocalName))
     return std::move(*Val);
   return Default.str();
 }
+
+llvm::Optional<FixItHint>
+ClangTidyCheck::createMainFileIncludeInsertion(StringRef Include) {
+  if (!Context->hasIncludeInserter()) {
+    // Only crash on debug builds
+    assert(false && "No IncludeInserter registered");
+    return llvm::None;
+  }
+  return Context->getIncludeInserter().createMainFileIncludeInsertion(Include);
+}
+
+llvm::Optional<FixItHint>
+ClangTidyCheck::createIncludeInsertion(FileID File, StringRef Include) {
+  if (!Context->hasIncludeInserter()) {
+    // Only crash on debug builds
+    assert(false && "No IncludeInserter registered");
+    return llvm::None;
+  }
+  return Context->getIncludeInserter().createIncludeInsertion(File, Include);
+}
 } // 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 "IncludeInserter.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;
DiagLevelAndFormatString getDiagLevelAndFormatString(unsigned DiagnosticID,
                                                        SourceLocation Loc) {
     return DiagLevelAndFormatString(
         static_cast<DiagnosticIDs::Level>(
             DiagEngine->getDiagnosticLevel(DiagnosticID, Loc)),
         std::string(
             DiagEngine->getDiagnosticIDs()->getDescription(DiagnosticID)));
   }
 
+  bool hasIncludeInserter() const { return Inserter.hasValue(); }
+  IncludeInserter &getIncludeInserter() {
+    assert(hasIncludeInserter());
+    return *Inserter;
+  }
+
+  void registerIncludeInserter(IncludeSorter::IncludeStyle Style);
+  void registerIncludeInserter(StringRef CheckName);
+
 private:
   // Writes to Stats.
   friend class ClangTidyDiagnosticConsumer;
 
   DiagnosticsEngine *DiagEngine;
   std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
 
   std::string CurrentFile;
   ClangTidyOptions CurrentOptions;
 
+  llvm::Optional<IncludeInserter> Inserter;
+
   std::unique_ptr<CachedGlobList> CheckFilter;
   std::unique_ptr<CachedGlobList> WarningAsErrorFilter;
 
   LangOptions LangOpts;
 
   ClangTidyStats Stats;
 
   std::string CurrentBuildDirectory;

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

 ///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 ///  for details on setting it up with LLVM source tree.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
 #include "GlobList.h"
+#include "IncludeSorter.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/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/DiagnosticRenderer.h"

 }
 
 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);
+  this->Inserter.reset();
 }
 
 void ClangTidyContext::setASTContext(ASTContext *Context) {
   DiagEngine->SetArgToStringFn(&FormatASTNodeDiagnosticArgument, Context);
   LangOpts = Context->getLangOpts();
 }
 
 const ClangTidyGlobalOptions &ClangTidyContext::getGlobalOptions() const {
if (!Note.Fix.empty()) {
         // We have 2 different fixes in notes, bail out.
         return nullptr;
       Result = &Note.Fix;
     }
   }
   return Result;
 }
 
+void ClangTidyContext::registerIncludeInserter(
+    IncludeSorter::IncludeStyle Style) {
+  if (!Inserter) {
+    Inserter.emplace(Style);
+  }
+}
+
+void ClangTidyContext::registerIncludeInserter(StringRef CheckName) {
+  const ClangTidyOptions::OptionMap &Options = getOptions().CheckOptions;
+  {
+    // Check and warn if the option was set Locally, for old clang-tidy configs.
+    SmallString<64> Buffer{CheckName, ".IncludeStyle"};
+    if (Options.count(Buffer)) {
+      configurationDiag(
+          "Option '%0' is deprecated; use the global 'IncludeStyle' instead")
+          << Buffer;
+    }
+  }
+  if (Inserter)
+    return;
+  auto SetDefault = [this] { registerIncludeInserter(IncludeSorter::IS_LLVM); };
+  auto It = Options.find("IncludeStyle");
+  if (It == Options.end()) {
+    SetDefault();
+    return;
+  }
+  StringRef Input = It->getValue().Value;
+  StringRef Closest;
+  auto Mapping = IncludeSorter::getStyleMapping();
+  for (unsigned I = 0, E = Mapping.size(); I < E; ++I) {
+    if (Input == Mapping[I]) {
+      registerIncludeInserter(static_cast<IncludeSorter::IncludeStyle>(I));
+      return;
+    }
+    if (Input.equals_insensitive(Mapping[I])) {
+      Closest = Mapping[I];
+      break;
+    }
+    auto Edit = Input.edit_distance(Mapping[I], true, 1);
+    if (Edit < 2) {
+      Closest = Mapping[I];
+      break;
+    }
+  }
+  if (Closest.empty())
+    configurationDiag("Couldn't parse '%0' as an 'IncludeStyle'")
+        << It->getValue().Value;
+  else
+    configurationDiag(
+        "Couldn't parse '%0' as an 'IncludeStyle'; did you mean %1")
+        << It->getValue().Value << Closest;
+  SetDefault();
+}
 } // namespace tidy
 } // namespace clang
 
 void ClangTidyDiagnosticConsumer::HandleDiagnostic(
     DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
   if (LastErrorWasIgnored && DiagLevel == DiagnosticsEngine::Note)
     return;
 

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

 #include "IncludeSorter.h"
 #include "clang/Basic/Diagnostic.h"
 #include "llvm/ADT/StringSet.h"
 #include <memory>
 
 namespace clang {
 class Preprocessor;
 namespace tidy {
-namespace utils {
 
 /// Produces fixes to insert specified includes to source files, if not
 /// yet present.
 ///
 /// ``IncludeInserter`` can be used in clang-tidy checks in the following way:
 /// \code
 /// #include "../ClangTidyCheck.h"
 /// #include "../utils/IncludeInserter.h"
private:
 
   llvm::DenseMap<FileID, std::unique_ptr<IncludeSorter>> IncludeSorterByFile;
   llvm::DenseMap<FileID, llvm::StringSet<>> InsertedHeaders;
   const SourceManager *SourceMgr{nullptr};
   const IncludeSorter::IncludeStyle Style;
   friend class IncludeInserterCallback;
 };
 
-} // namespace utils
 } // namespace tidy
 } // namespace clang
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDEINSERTER_H

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

 //===-------- IncludeInserter.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 "IncludeInserter.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/Token.h"
 
 namespace clang {
 namespace tidy {
-namespace utils {
 
 class IncludeInserterCallback : public PPCallbacks {
 public:
   explicit IncludeInserterCallback(IncludeInserter *Inserter)
       : Inserter(Inserter) {}
   // Implements PPCallbacks::InclusionDirective(). Records the names and source
   // locations of the inclusions in the main source file being processed.
   void InclusionDirective(SourceLocation HashLocation,
void IncludeInserter::addInclude(StringRef FileName, bool IsAngled,
                                  SourceLocation HashLocation,
                                  SourceLocation EndLocation) {
   assert(SourceMgr && "SourceMgr shouldn't be null; did you remember to call "
                       "registerPreprocessor()?");
   FileID FileID = SourceMgr->getFileID(HashLocation);
   getOrCreate(FileID).addInclude(FileName, IsAngled, HashLocation, EndLocation);
 }
 
-} // namespace utils
 } // namespace tidy
 } // namespace clang

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

 //===------------ IncludeSorter.h - 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDESORTER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDESORTER_H
 
-#include "../ClangTidyCheck.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/ADT/StringMap.h"
 #include <string>
 
 namespace clang {
+class SourceManager;
 namespace tidy {
-namespace utils {
 
 /// Class used by ``IncludeInserterCallback`` to record the names of the
 /// inclusions in a given source file being processed and generate the necessary
 /// commands to sort the inclusions according to the precedence encoded in
 /// ``IncludeKinds``.
 class IncludeSorter {
 public:
   /// Supported include styles.
   enum IncludeStyle { IS_LLVM = 0, IS_Google = 1, IS_Google_ObjC };
+  static ArrayRef<StringRef> getStyleMapping();
 
   /// The classifications of inclusions, in the order they should be sorted.
   enum IncludeKinds {
     IK_MainTUInclude = 0,    ///< e.g. ``#include "foo.h"`` when editing foo.cc
     IK_CSystemInclude = 1,   ///< e.g. ``#include <stdio.h>``
     IK_CXXSystemInclude = 2, ///< e.g. ``#include <vector>``
     IK_NonSystemInclude = 3, ///< e.g. ``#include "bar.h"``
     IK_GeneratedInclude = 4, ///< e.g. ``#include "bar.proto.h"``
     IK_InvalidInclude = 5    ///< total number of valid ``IncludeKind``s
   };
 
-  /// ``IncludeSorter`` constructor; takes the FileID and name of the file to be
-  /// processed by the sorter.
+  /// ``IncludeSorter`` constructor; takes the FileID and name of the file to
+  /// be processed by the sorter.
   IncludeSorter(const SourceManager *SourceMgr, const FileID FileID,
                 StringRef FileName, IncludeStyle Style);
 
   /// Adds the given include directive to the sorter.
   void addInclude(StringRef FileName, bool IsAngled,
                   SourceLocation HashLocation, SourceLocation EndLocation);
 
-  /// Creates a quoted inclusion directive in the right sort order. Returns None
-  /// on error or if header inclusion directive for header already exists.
+  /// Creates a quoted inclusion directive in the right sort order. Returns
+  /// None on error or if header inclusion directive for header already
+  /// exists.
   Optional<FixItHint> createIncludeInsertion(StringRef FileName, bool IsAngled);
 
 private:
   typedef SmallVector<SourceRange, 1> SourceRangeVector;
 
   const SourceManager *SourceMgr;
   const IncludeStyle Style;
   FileID CurrentFileID;
   /// The file name stripped of common suffixes.
   StringRef CanonicalFile;
   /// Locations of visited include directives.
   SourceRangeVector SourceLocations;
   /// Mapping from file name to #include locations.
   llvm::StringMap<SourceRangeVector> IncludeLocations;
   /// Includes sorted into buckets.
   SmallVector<std::string, 1> IncludeBucket[IK_InvalidInclude];
 };
-
-} // namespace utils
-
-template <> struct OptionEnumMapping<utils::IncludeSorter::IncludeStyle> {
-  static ArrayRef<std::pair<utils::IncludeSorter::IncludeStyle, StringRef>>
-  getEnumMapping();
-};
 } // namespace tidy
 } // namespace clang
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDESORTER_H

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

 //===---------- IncludeSorter.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 "IncludeSorter.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
 #include <algorithm>
 
 namespace clang {
 namespace tidy {
-namespace utils {
 
 namespace {
 
 StringRef removeFirstSuffix(StringRef Str, ArrayRef<const char *> Suffixes) {
   for (StringRef Suffix : Suffixes) {
     if (Str.endswith(Suffix)) {
       return Str.substr(0, Str.size() - Suffix.size());
     }
StringRef Canonical =
                           {"_unittest", "_regtest", "_test", "Test"});
 
     // Objective-C categories have a `+suffix` format, but should be grouped
     // with the file they are a category of.
     size_t StartIndex = Canonical.find_last_of('/');
     if (StartIndex == StringRef::npos) {
       StartIndex = 0;
     }
-    return Canonical.substr(
-        0, Canonical.find_first_of('+', StartIndex));
+    return Canonical.substr(0, Canonical.find_first_of('+', StartIndex));
   }
   return removeFirstSuffix(
       removeFirstSuffix(Str, {".cc", ".cpp", ".c", ".h", ".hpp"}),
       {"_unittest", "_regtest", "_test"});
 }
 
 // Scan to the end of the line and return the offset of the next line.
 size_t findNextLine(const char *Text) {
determineIncludeKind(StringRef CanonicalFile, StringRef IncludeFile,
   // replaced by "/internal/".
   if (IsAngled) {
     // If the system include (<foo>) ends with ".h", then it is a normal C-style
     // include. Otherwise assume it is a C++-style extensionless include.
     return IncludeFile.endswith(".h") ? IncludeSorter::IK_CSystemInclude
                                       : IncludeSorter::IK_CXXSystemInclude;
   }
   StringRef CanonicalInclude = makeCanonicalName(IncludeFile, Style);
-  if (CanonicalFile.endswith(CanonicalInclude)
-      || CanonicalInclude.endswith(CanonicalFile)) {
+  if (CanonicalFile.endswith(CanonicalInclude) ||
+      CanonicalInclude.endswith(CanonicalFile)) {
     return IncludeSorter::IK_MainTUInclude;
   }
   if ((Style == IncludeSorter::IS_Google) ||
       (Style == IncludeSorter::IS_Google_ObjC)) {
     std::pair<StringRef, StringRef> Parts = CanonicalInclude.split("/public/");
     std::string AltCanonicalInclude =
         Parts.first.str() + "/internal/" + Parts.second.str();
     std::string ProtoCanonicalInclude =
Optional<FixItHint> IncludeSorter::createIncludeInsertion(StringRef FileName,
   }
   // Create a block before.
   const std::string &FirstInclude = IncludeBucket[NonEmptyKind][0];
   SourceRange FirstIncludeLocation = IncludeLocations[FirstInclude].back();
   IncludeStmt.append("\n");
   return FixItHint::CreateInsertion(FirstIncludeLocation.getBegin(),
                                     IncludeStmt);
 }
-
-} // namespace utils
-
-llvm::ArrayRef<std::pair<utils::IncludeSorter::IncludeStyle, StringRef>>
-OptionEnumMapping<utils::IncludeSorter::IncludeStyle>::getEnumMapping() {
-  static constexpr std::pair<utils::IncludeSorter::IncludeStyle, StringRef>
-      Mapping[] = {{utils::IncludeSorter::IS_LLVM, "llvm"},
-                   {utils::IncludeSorter::IS_Google, "google"},
-                   {utils::IncludeSorter::IS_Google_ObjC, "google-objc"}};
+static constexpr StringRef Mapping[] = {"llvm", "google", "google-objc"};
+llvm::ArrayRef<StringRef> IncludeSorter::getStyleMapping() {
   return makeArrayRef(Mapping);
 }
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.h

 //===--- StringFindStartswithCheck.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_ABSEIL_STRINGFINDSTARTSWITHCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTARTSWITHCHECK_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace tidy {
 namespace abseil {
 
 // Find string.find(...) == 0 comparisons and suggest replacing with StartsWith.
 // FIXME(niko): Add similar check for EndsWith
 // FIXME(niko): Add equivalent modernize checks for C++20's std::starts_With
 class StringFindStartswithCheck : public ClangTidyCheck {
 public:
   using ClangTidyCheck::ClangTidyCheck;
   StringFindStartswithCheck(StringRef Name, ClangTidyContext *Context);
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   const std::vector<std::string> StringLikeClasses;
-  utils::IncludeInserter IncludeInserter;
   const std::string AbseilStringsMatchHeader;
 };
 
 } // namespace abseil
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTARTSWITHCHECK_H

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp

 namespace tidy {
 namespace abseil {
 
 StringFindStartswithCheck::StringFindStartswithCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       StringLikeClasses(utils::options::parseStringList(
           Options.get("StringLikeClasses", "::std::basic_string"))),
-      IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
-                                               utils::IncludeSorter::IS_LLVM)),
       AbseilStringsMatchHeader(
-          Options.get("AbseilStringsMatchHeader", "absl/strings/match.h")) {}
+          Options.get("AbseilStringsMatchHeader", "absl/strings/match.h")) {
+  registerIncludeInserter();
+}
 
 void StringFindStartswithCheck::registerMatchers(MatchFinder *Finder) {
   auto ZeroLiteral = integerLiteral(equals(0));
   auto StringClassMatcher = cxxRecordDecl(hasAnyName(SmallVector<StringRef, 4>(
       StringLikeClasses.begin(), StringLikeClasses.end())));
   auto StringType = hasUnqualifiedDesugaredType(
       recordType(hasDeclaration(StringClassMatcher)));
 
void StringFindStartswithCheck::check(const MatchFinder::MatchResult &Result) {
   Diagnostic << FixItHint::CreateReplacement(
       ComparisonExpr->getSourceRange(),
       ((Neg ? "!absl::StartsWith(" : "absl::StartsWith(") + HaystackExprCode +
        ", " + NeedleExprCode + ")")
           .str());
 
   // Create a preprocessor #include FixIt hint (createIncludeInsertion checks
   // whether this already exists).
-  Diagnostic << IncludeInserter.createIncludeInsertion(
+  Diagnostic << createIncludeInsertion(
       Source.getFileID(ComparisonExpr->getBeginLoc()),
       AbseilStringsMatchHeader);
 }
 
-void StringFindStartswithCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  IncludeInserter.registerPreprocessor(PP);
-}
-
 void StringFindStartswithCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StringLikeClasses",
                 utils::options::serializeStringList(StringLikeClasses));
-  Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
   Options.store(Opts, "AbseilStringsMatchHeader", AbseilStringsMatchHeader);
 }
 
 } // namespace abseil
 } // namespace tidy
 } // namespace clang

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

 //===--- ImplicitWideningOfMultiplicationResultCheck.h ----------*- 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_IMPLICITWIDENINGOFMULTIPLICATIONRESULTCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_IMPLICITWIDENINGOFMULTIPLICATIONRESULTCHECK_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 /// Diagnoses instances of an implicit widening of multiplication result.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-implicit-widening-of-multiplication-result.html
 class ImplicitWideningOfMultiplicationResultCheck : public ClangTidyCheck {
   const ast_matchers::MatchFinder::MatchResult *Result;
   bool ShouldUseCXXStaticCast;
   bool ShouldUseCXXHeader;
 
   llvm::Optional<FixItHint> includeStddefHeader(SourceLocation File);
 
   void handleImplicitCastExpr(const ImplicitCastExpr *ICE);
   void handlePointerOffsetting(const Expr *E);
 
 public:
   ImplicitWideningOfMultiplicationResultCheck(StringRef Name,
                                               ClangTidyContext *Context);
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   const bool UseCXXStaticCastsInCppSources;
   const bool UseCXXHeadersInCppSources;
-  utils::IncludeInserter IncludeInserter;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_IMPLICITWIDENINGOFMULTIPLICATIONRESULTCHECK_H

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

 }
 
 ImplicitWideningOfMultiplicationResultCheck::
     ImplicitWideningOfMultiplicationResultCheck(StringRef Name,
                                                 ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       UseCXXStaticCastsInCppSources(
           Options.get("UseCXXStaticCastsInCppSources", true)),
-      UseCXXHeadersInCppSources(Options.get("UseCXXHeadersInCppSources", true)),
-      IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
-                                               utils::IncludeSorter::IS_LLVM)) {
-}
-
-void ImplicitWideningOfMultiplicationResultCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  IncludeInserter.registerPreprocessor(PP);
+      UseCXXHeadersInCppSources(
+          Options.get("UseCXXHeadersInCppSources", true)) {
+  registerIncludeInserter();
 }
 
 void ImplicitWideningOfMultiplicationResultCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "UseCXXStaticCastsInCppSources",
                 UseCXXStaticCastsInCppSources);
   Options.store(Opts, "UseCXXHeadersInCppSources", UseCXXHeadersInCppSources);
-  Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
 }
 
 llvm::Optional<FixItHint>
 ImplicitWideningOfMultiplicationResultCheck::includeStddefHeader(
     SourceLocation File) {
-  return IncludeInserter.createIncludeInsertion(
-      Result->SourceManager->getFileID(File),
-      ShouldUseCXXHeader ? "<cstddef>" : "<stddef.h>");
+  return createIncludeInsertion(Result->SourceManager->getFileID(File),
+                                ShouldUseCXXHeader ? "<cstddef>"
+                                                   : "<stddef.h>");
 }
 
 void ImplicitWideningOfMultiplicationResultCheck::handleImplicitCastExpr(
     const ImplicitCastExpr *ICE) {
   ASTContext *Context = Result->Context;
 
   const Expr *E = ICE->getSubExpr()->IgnoreParens();
   QualType Ty = ICE->getType();

clang-tools-extra/clang-tidy/cppcoreguidelines/InitVariablesCheck.h

 //===--- InitVariablesCheck.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_CPPCOREGUIDELINES_INITVARIABLESCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_INITVARIABLESCHECK_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 #include "../utils/OptionsUtils.h"
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 /// Find uninitialized local variables.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-init-variables.html
 class InitVariablesCheck : public ClangTidyCheck {
 public:
   InitVariablesCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  utils::IncludeInserter IncludeInserter;
   const std::string MathHeader;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_INITVARIABLESCHECK_H

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

 
 namespace {
 AST_MATCHER(VarDecl, isLocalVarDecl) { return Node.isLocalVarDecl(); }
 } // namespace
 
 InitVariablesCheck::InitVariablesCheck(StringRef Name,
                                        ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
-                                               utils::IncludeSorter::IS_LLVM)),
-      MathHeader(Options.get("MathHeader", "<math.h>")) {}
+      MathHeader(Options.get("MathHeader", "<math.h>")) {
+  registerIncludeInserter();
+}
 
 void InitVariablesCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
   Options.store(Opts, "MathHeader", MathHeader);
 }
 
 void InitVariablesCheck::registerMatchers(MatchFinder *Finder) {
   std::string BadDecl = "badDecl";
   Finder->addMatcher(
       varDecl(unless(hasInitializer(anything())), unless(isInstantiated()),
               isLocalVarDecl(), unless(isStaticLocal()), isDefinition(),
               unless(hasParent(cxxCatchStmt())),
               optionally(hasParent(declStmt(hasParent(
                   cxxForRangeStmt(hasLoopVariable(varDecl().bind(BadDecl))))))),
               unless(equalsBoundNode(BadDecl)))
           .bind("vardecl"),
       this);
 }
 
-void InitVariablesCheck::registerPPCallbacks(const SourceManager &SM,
-                                             Preprocessor *PP,
-                                             Preprocessor *ModuleExpanderPP) {
-  IncludeInserter.registerPreprocessor(PP);
-}
-
 void InitVariablesCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<VarDecl>("vardecl");
   const ASTContext &Context = *Result.Context;
   const SourceManager &Source = Context.getSourceManager();
 
   // We want to warn about cases where the type name
   // comes from a macro like this:
   //
auto Diagnostic =
         diag(MatchedDecl->getLocation(), "variable %0 is not initialized")
         << MatchedDecl;
     if (*InitializationString != nullptr)
       Diagnostic << FixItHint::CreateInsertion(
           MatchedDecl->getLocation().getLocWithOffset(
               MatchedDecl->getName().size()),
           *InitializationString);
     if (AddMathInclude) {
-      Diagnostic << IncludeInserter.createIncludeInsertion(
+      Diagnostic << createIncludeInsertion(
           Source.getFileID(MatchedDecl->getBeginLoc()), MathHeader);
     }
   }
 }
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.h

 //===--- ProBoundsConstantArrayIndexCheck.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_CPPCOREGUIDELINES_PRO_BOUNDS_CONSTANT_ARRAY_INDEX_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_CONSTANT_ARRAY_INDEX_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 /// This checks that all array subscriptions on static arrays and std::arrays
 /// have a constant index and are within bounds
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-constant-array-index.html
 class ProBoundsConstantArrayIndexCheck : public ClangTidyCheck {
   const std::string GslHeader;
-  utils::IncludeInserter Inserter;
 
 public:
   ProBoundsConstantArrayIndexCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_CONSTANT_ARRAY_INDEX_H

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 ProBoundsConstantArrayIndexCheck::ProBoundsConstantArrayIndexCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context), GslHeader(Options.get("GslHeader", "")),
-      Inserter(Options.getLocalOrGlobal("IncludeStyle",
-                                        utils::IncludeSorter::IS_LLVM)) {}
-
+    : ClangTidyCheck(Name, Context), GslHeader(Options.get("GslHeader", "")) {
+  registerIncludeInserter();
+}
 void ProBoundsConstantArrayIndexCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "GslHeader", GslHeader);
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
-}
-
-void ProBoundsConstantArrayIndexCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  Inserter.registerPreprocessor(PP);
 }
 
 void ProBoundsConstantArrayIndexCheck::registerMatchers(MatchFinder *Finder) {
   // Note: if a struct contains an array member, the compiler-generated
   // constructor has an arraySubscriptExpr.
   Finder->addMatcher(arraySubscriptExpr(hasBase(ignoringImpCasts(hasType(
                                             constantArrayType().bind("type")))),
                                         hasIndex(expr().bind("index")),
auto Diag = diag(Matched->getExprLoc(),
                      "instead");
     if (!GslHeader.empty()) {
       Diag << FixItHint::CreateInsertion(BaseRange.getBegin(), "gsl::at(")
            << FixItHint::CreateReplacement(
                   SourceRange(BaseRange.getEnd().getLocWithOffset(1),
                               IndexRange.getBegin().getLocWithOffset(-1)),
                   ", ")
            << FixItHint::CreateReplacement(Matched->getEndLoc(), ")")
-           << Inserter.createMainFileIncludeInsertion(GslHeader);
+           << createMainFileIncludeInsertion(GslHeader);
     }
     return;
   }
 
   const auto *StdArrayDecl =
       Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("type");
 
   // For static arrays, this is handled in clang-diagnostic-array-bounds.

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

 //===--- UniqueptrResetReleaseCheck.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_UNIQUEPTRRESETRELEASECHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNIQUEPTRRESETRELEASECHECK_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 /// Find and replace `unique_ptr::reset(release())` with `std::move()`.
 ///
 /// Example:
public:
   UniqueptrResetReleaseCheck(StringRef Name, ClangTidyContext *Context);
 
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     // Only register the matchers for C++11; the functionality currently does
     // not
     // provide any benefit to other languages, despite being benign.
     return LangOpts.CPlusPlus11;
   }
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
-
-private:
-  utils::IncludeInserter Inserter;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNIQUEPTRRESETRELEASECHECK_H

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 UniqueptrResetReleaseCheck::UniqueptrResetReleaseCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      Inserter(Options.getLocalOrGlobal("IncludeStyle",
-                                        utils::IncludeSorter::IS_LLVM)) {}
-
-void UniqueptrResetReleaseCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
-}
-
-void UniqueptrResetReleaseCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  Inserter.registerPreprocessor(PP);
+    : ClangTidyCheck(Name, Context) {
+  registerIncludeInserter();
 }
 
 void UniqueptrResetReleaseCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       cxxMemberCallExpr(
           callee(memberExpr(
                      member(cxxMethodDecl(
                          hasName("reset"),
D << FixItHint::CreateReplacement(
            CharSourceRange::getCharRange(ResetMember->getOperatorLoc(),
                                          Right->getBeginLoc()),
            AssignmentText)
     << FixItHint::CreateReplacement(
            CharSourceRange::getTokenRange(ReleaseMember->getOperatorLoc(),
                                           ResetCall->getEndLoc()),
            TrailingText);
   if (NeedsUtilityInclude)
-    D << Inserter.createIncludeInsertion(
+    D << createIncludeInsertion(
         Result.SourceManager->getFileID(ResetMember->getBeginLoc()),
         "<utility>");
 }
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.h

 //===--- LoopConvertCheck.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_MODERNIZE_LOOP_CONVERT_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_LOOP_CONVERT_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 #include "LoopConvertUtils.h"
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 class LoopConvertCheck : public ClangTidyCheck {
 public:
   LoopConvertCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   struct RangeDescriptor {
     RangeDescriptor();
     bool ContainerNeedsDereference;
     bool DerefByConstRef;
     bool DerefByValue;
private:
 
   StringRef getReverseFunction() const;
   StringRef getReverseHeader() const;
 
   std::unique_ptr<TUTrackingInfo> TUInfo;
   const unsigned long long MaxCopySize;
   const Confidence::Level MinConfidence;
   const VariableNamer::NamingStyle NamingStyle;
-  utils::IncludeInserter Inserter;
   bool UseReverseRanges;
   const bool UseCxx20IfAvailable;
   std::string ReverseFunction;
   std::string ReverseHeader;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_LOOP_CONVERT_H

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

LoopConvertCheck::RangeDescriptor::RangeDescriptor()
     : ContainerNeedsDereference(false), DerefByConstRef(false),
       DerefByValue(false), NeedsReverseCall(false) {}
 
 LoopConvertCheck::LoopConvertCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), TUInfo(new TUTrackingInfo),
       MaxCopySize(Options.get("MaxCopySize", 16ULL)),
       MinConfidence(Options.get("MinConfidence", Confidence::CL_Reasonable)),
       NamingStyle(Options.get("NamingStyle", VariableNamer::NS_CamelCase)),
-      Inserter(Options.getLocalOrGlobal("IncludeStyle",
-                                        utils::IncludeSorter::IS_LLVM)),
       UseCxx20IfAvailable(Options.get("UseCxx20ReverseRanges", true)),
       ReverseFunction(Options.get("MakeReverseRangeFunction", "")),
       ReverseHeader(Options.get("MakeReverseRangeHeader", "")) {
+  registerIncludeInserter();
 
   if (ReverseFunction.empty() && !ReverseHeader.empty()) {
     configurationDiag(
         "modernize-loop-convert: 'MakeReverseRangeHeader' is set but "
         "'MakeReverseRangeFunction' is not, disabling reverse loop "
         "transformation");
     UseReverseRanges = false;
   } else if (ReverseFunction.empty()) {
     UseReverseRanges = UseCxx20IfAvailable && getLangOpts().CPlusPlus20;
   } else {
     UseReverseRanges = true;
   }
 }
 
 void LoopConvertCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MaxCopySize", MaxCopySize);
   Options.store(Opts, "MinConfidence", MinConfidence);
   Options.store(Opts, "NamingStyle", NamingStyle);
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
   Options.store(Opts, "UseCxx20ReverseRanges", UseCxx20IfAvailable);
   Options.store(Opts, "MakeReverseRangeFunction", ReverseFunction);
   Options.store(Opts, "MakeReverseRangeHeader", ReverseHeader);
 }
 
-void LoopConvertCheck::registerPPCallbacks(const SourceManager &SM,
-                                           Preprocessor *PP,
-                                           Preprocessor *ModuleExpanderPP) {
-  Inserter.registerPreprocessor(PP);
-}
-
 void LoopConvertCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(traverse(TK_AsIs, makeArrayLoopMatcher()), this);
   Finder->addMatcher(traverse(TK_AsIs, makeIteratorLoopMatcher(false)), this);
   Finder->addMatcher(traverse(TK_AsIs, makePseudoArrayLoopMatcher()), this);
   if (UseReverseRanges)
     Finder->addMatcher(traverse(TK_AsIs, makeIteratorLoopMatcher(true)), this);
 }
 
void LoopConvertCheck::doConversion(
   if (Descriptor.NeedsReverseCall)
     Output << "))";
   else
     Output << ')';
   FixIts.push_back(FixItHint::CreateReplacement(
       CharSourceRange::getTokenRange(ParenRange), Range));
 
   if (Descriptor.NeedsReverseCall && !getReverseHeader().empty()) {
-    if (Optional<FixItHint> Insertion = Inserter.createIncludeInsertion(
+    if (Optional<FixItHint> Insertion = createIncludeInsertion(
             Context->getSourceManager().getFileID(Loop->getBeginLoc()),
             getReverseHeader()))
       FixIts.push_back(*Insertion);
   }
   diag(Loop->getForLoc(), "use range-based for loop instead") << FixIts;
   TUInfo->getGeneratedDecls().insert(make_pair(Loop, VarName));
 }
 

clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.h

 //===--- MakeSmartPtrCheck.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_MODERNIZE_MAKE_SMART_PTR_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SMART_PTR_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 /// Base class for MakeSharedCheck and MakeUniqueCheck.
 class MakeSmartPtrCheck : public ClangTidyCheck {
 public:
   MakeSmartPtrCheck(StringRef Name, ClangTidyContext *Context,
                     StringRef MakeSmartPtrFunctionName);
   void registerMatchers(ast_matchers::MatchFinder *Finder) final;
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) final;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 protected:
   using SmartPtrTypeMatcher = ast_matchers::internal::BindableMatcher<QualType>;
 
   /// Returns matcher that match with different smart pointer types.
   ///
   /// Requires to bind pointer type (qualType) with PointerType string declared
   /// in this class.
   virtual SmartPtrTypeMatcher getSmartPointerTypeMatcher() const = 0;
 
   /// Returns whether the C++ version is compatible with current check.
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
 
   static const char PointerType[];
 
 private:
-  utils::IncludeInserter Inserter;
   const std::string MakeSmartPtrFunctionHeader;
   const std::string MakeSmartPtrFunctionName;
   const bool IgnoreMacros;
   const bool IgnoreDefaultInitialization;
 
   void checkConstruct(SourceManager &SM, ASTContext *Ctx,
                       const CXXConstructExpr *Construct, const QualType *Type,
                       const CXXNewExpr *New);

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

 
 } // namespace
 
 const char MakeSmartPtrCheck::PointerType[] = "pointerType";
 
 MakeSmartPtrCheck::MakeSmartPtrCheck(StringRef Name, ClangTidyContext *Context,
                                      StringRef MakeSmartPtrFunctionName)
     : ClangTidyCheck(Name, Context),
-      Inserter(Options.getLocalOrGlobal("IncludeStyle",
-                                        utils::IncludeSorter::IS_LLVM)),
       MakeSmartPtrFunctionHeader(
           Options.get("MakeSmartPtrFunctionHeader", "<memory>")),
       MakeSmartPtrFunctionName(
           Options.get("MakeSmartPtrFunction", MakeSmartPtrFunctionName)),
       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)),
       IgnoreDefaultInitialization(
-          Options.get("IgnoreDefaultInitialization", true)) {}
+          Options.get("IgnoreDefaultInitialization", true)) {
+  registerIncludeInserter();
+}
 
 void MakeSmartPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
   Options.store(Opts, "MakeSmartPtrFunctionHeader", MakeSmartPtrFunctionHeader);
   Options.store(Opts, "MakeSmartPtrFunction", MakeSmartPtrFunctionName);
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
   Options.store(Opts, "IgnoreDefaultInitialization",
                 IgnoreDefaultInitialization);
 }
 
 bool MakeSmartPtrCheck::isLanguageVersionSupported(
     const LangOptions &LangOpts) const {
   return LangOpts.CPlusPlus11;
 }
 
-void MakeSmartPtrCheck::registerPPCallbacks(const SourceManager &SM,
-                                            Preprocessor *PP,
-                                            Preprocessor *ModuleExpanderPP) {
-  Inserter.registerPreprocessor(PP);
-}
-
 void MakeSmartPtrCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
   // Calling make_smart_ptr from within a member function of a type with a
   // private or protected constructor would be ill-formed.
   auto CanCallCtor = unless(has(ignoringImpCasts(
       cxxConstructExpr(hasDeclaration(decl(unless(isPublic())))))));
 
   auto IsPlacement = hasAnyPlacementArg(anything());
 
bool MakeSmartPtrCheck::replaceNew(DiagnosticBuilder &Diag,
   }
   return true;
 }
 
 void MakeSmartPtrCheck::insertHeader(DiagnosticBuilder &Diag, FileID FD) {
   if (MakeSmartPtrFunctionHeader.empty()) {
     return;
   }
-  Diag << Inserter.createIncludeInsertion(FD, MakeSmartPtrFunctionHeader);
+  Diag << createIncludeInsertion(FD, MakeSmartPtrFunctionHeader);
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

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

ClangTidyOptions getModuleOptions() override {
     ClangTidyOptions Options;
     auto &Opts = Options.CheckOptions;
     // For types whose size in bytes is above this threshold, we prefer taking a
     // const-reference than making a copy.
     Opts["modernize-loop-convert.MaxCopySize"] = "16";
 
     Opts["modernize-loop-convert.MinConfidence"] = "reasonable";
     Opts["modernize-loop-convert.NamingStyle"] = "CamelCase";
-    Opts["modernize-pass-by-value.IncludeStyle"] = "llvm";    // Also: "google".
-    Opts["modernize-replace-auto-ptr.IncludeStyle"] = "llvm"; // Also: "google".
 
     // Comma-separated list of macros that behave like NULL.
     Opts["modernize-use-nullptr.NullMacros"] = "NULL";
     return Options;
   }
 };
 
 // Register the ModernizeTidyModule using this statically initialized variable.

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.h

 //===--- PassByValueCheck.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_MODERNIZE_PASS_BY_VALUE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_PASS_BY_VALUE_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 
 #include <memory>
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 class PassByValueCheck : public ClangTidyCheck {
 public:
   PassByValueCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
-private:
-  utils::IncludeInserter Inserter;
   const bool ValuesOnly;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_PASS_BY_VALUE_H

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

collectParamDecls(const CXXConstructorDecl *Ctor,
 
   for (const FunctionDecl *Redecl : Ctor->redecls())
     Results.push_back(Redecl->getParamDecl(ParamIdx));
   return Results;
 }
 
 PassByValueCheck::PassByValueCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      Inserter(Options.getLocalOrGlobal("IncludeStyle",
-                                        utils::IncludeSorter::IS_LLVM)),
-      ValuesOnly(Options.get("ValuesOnly", false)) {}
+      ValuesOnly(Options.get("ValuesOnly", false)) {
+  registerIncludeInserter();
+}
 
 void PassByValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
   Options.store(Opts, "ValuesOnly", ValuesOnly);
 }
 
 void PassByValueCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       traverse(
           TK_AsIs,
           cxxConstructorDecl(
Finder->addMatcher(
                               isCopyConstructor(), unless(isDeleted()),
                               hasDeclContext(
                                   cxxRecordDecl(isMoveConstructible())))))))
                       .bind("Initializer")))
               .bind("Ctor")),
       this);
 }
 
-void PassByValueCheck::registerPPCallbacks(const SourceManager &SM,
-                                           Preprocessor *PP,
-                                           Preprocessor *ModuleExpanderPP) {
-  Inserter.registerPreprocessor(PP);
-}
-
 void PassByValueCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("Ctor");
   const auto *ParamDecl = Result.Nodes.getNodeAs<ParmVarDecl>("Param");
   const auto *Initializer =
       Result.Nodes.getNodeAs<CXXCtorInitializer>("Initializer");
   SourceManager &SM = *Result.SourceManager;
 
   // If the parameter is used or anything other than the copy, do not apply
for (const ParmVarDecl *ParmDecl : collectParamDecls(Ctor, ParamDecl)) {
       Diag << FixItHint::CreateReplacement(TypeRange, ValueStr);
     }
   }
 
   // Use std::move in the initialization list.
   Diag << FixItHint::CreateInsertion(Initializer->getRParenLoc(), ")")
        << FixItHint::CreateInsertion(
               Initializer->getLParenLoc().getLocWithOffset(1), "std::move(")
-       << Inserter.createIncludeInsertion(
+       << createIncludeInsertion(
               Result.SourceManager->getFileID(Initializer->getSourceLocation()),
               "<utility>");
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.h

 //===--- ReplaceAutoPtrCheck.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_MODERNIZE_REPLACE_AUTO_PTR_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACE_AUTO_PTR_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 /// Transforms the deprecated `std::auto_ptr` into the C++11 `std::unique_ptr`.
 ///
 /// Note that both the `std::auto_ptr` type and the transfer of ownership are

 ///   i = std::move(j);
 /// \endcode
 class ReplaceAutoPtrCheck : public ClangTidyCheck {
 public:
   ReplaceAutoPtrCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-
-private:
-  utils::IncludeInserter Inserter;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACE_AUTO_PTR_H

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

 ///   b = "this string won't match";
 /// \endcode
 AST_MATCHER(Expr, isLValue) { return Node.getValueKind() == VK_LValue; }
 
 } // namespace
 
 ReplaceAutoPtrCheck::ReplaceAutoPtrCheck(StringRef Name,
                                          ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      Inserter(Options.getLocalOrGlobal("IncludeStyle",
-                                        utils::IncludeSorter::IS_LLVM)) {}
-
-void ReplaceAutoPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
+    : ClangTidyCheck(Name, Context) {
+  registerIncludeInserter();
 }
-
 void ReplaceAutoPtrCheck::registerMatchers(MatchFinder *Finder) {
   auto AutoPtrDecl = recordDecl(hasName("auto_ptr"), isInStdNamespace());
   auto AutoPtrType = qualType(hasDeclaration(AutoPtrDecl));
 
   //   std::auto_ptr<int> a;
   //        ^~~~~~~~~~~~~
   //
   //   typedef std::auto_ptr<int> int_ptr_t;
Finder->addMatcher(
       this);
   Finder->addMatcher(
       traverse(TK_AsIs,
                cxxConstructExpr(hasType(AutoPtrType), argumentCountIs(1),
                                 hasArgument(0, MovableArgumentMatcher))),
       this);
 }
 
-void ReplaceAutoPtrCheck::registerPPCallbacks(const SourceManager &SM,
-                                              Preprocessor *PP,
-                                              Preprocessor *ModuleExpanderPP) {
-  Inserter.registerPreprocessor(PP);
-}
-
 void ReplaceAutoPtrCheck::check(const MatchFinder::MatchResult &Result) {
   SourceManager &SM = *Result.SourceManager;
   if (const auto *E =
           Result.Nodes.getNodeAs<Expr>(AutoPtrOwnershipTransferId)) {
     CharSourceRange Range = Lexer::makeFileCharRange(
         CharSourceRange::getTokenRange(E->getSourceRange()), SM, LangOptions());
 
     if (Range.isInvalid())
       return;
 
     auto Diag = diag(Range.getBegin(), "use std::move to transfer ownership")
                 << FixItHint::CreateInsertion(Range.getBegin(), "std::move(")
                 << FixItHint::CreateInsertion(Range.getEnd(), ")")
-                << Inserter.createMainFileIncludeInsertion("<utility>");
+                << createMainFileIncludeInsertion("<utility>");
 
     return;
   }
 
   SourceLocation AutoPtrLoc;
   if (const auto *TL = Result.Nodes.getNodeAs<TypeLoc>(AutoPtrTokenId)) {
     //   std::auto_ptr<int> i;
     //        ^

clang-tools-extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.h

 //===--- ReplaceRandomShuffleCheck.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_MODERNIZE_REPLACE_RANDOM_SHUFFLE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACE_RANDOM_SHUFFLE_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 /// std::random_shuffle will be removed as of C++17. This check will find and
 /// replace all occurrences of std::random_shuffle with std::shuffle.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/modernize-replace-random-shuffle.html
 class ReplaceRandomShuffleCheck : public ClangTidyCheck {
 public:
   ReplaceRandomShuffleCheck(StringRef Name, ClangTidyContext *Context);
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   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:
-  utils::IncludeInserter IncludeInserter;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACE_RANDOM_SHUFFLE_H

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 ReplaceRandomShuffleCheck::ReplaceRandomShuffleCheck(StringRef Name,
                                                      ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
-                                               utils::IncludeSorter::IS_LLVM)) {
+    : ClangTidyCheck(Name, Context) {
+  registerIncludeInserter();
 }
 
 void ReplaceRandomShuffleCheck::registerMatchers(MatchFinder *Finder) {
   const auto Begin = hasArgument(0, expr());
   const auto End = hasArgument(1, expr());
   const auto RandomFunc = hasArgument(2, expr().bind("randomFunc"));
   Finder->addMatcher(
       traverse(
           TK_AsIs,
           callExpr(
               anyOf(allOf(Begin, End, argumentCountIs(2)),
                     allOf(Begin, End, RandomFunc, argumentCountIs(3))),
               hasDeclaration(functionDecl(hasName("::std::random_shuffle"))),
               has(implicitCastExpr(has(declRefExpr().bind("name")))))
               .bind("match")),
       this);
 }
 
-void ReplaceRandomShuffleCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  IncludeInserter.registerPreprocessor(PP);
-}
-
-void ReplaceRandomShuffleCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
-}
-
 void ReplaceRandomShuffleCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<DeclRefExpr>("name");
   const auto *MatchedArgumentThree = Result.Nodes.getNodeAs<Expr>("randomFunc");
   const auto *MatchedCallExpr = Result.Nodes.getNodeAs<CallExpr>("match");
 
   if (MatchedCallExpr->getBeginLoc().isMacroID())
     return;
 
void ReplaceRandomShuffleCheck::check(const MatchFinder::MatchResult &Result) {
   StringRef ContainerText = Lexer::getSourceText(
       CharSourceRange::getTokenRange(MatchedDecl->getSourceRange()),
       *Result.SourceManager, getLangOpts());
   if (ContainerText.startswith("std::"))
     NewName = "std::" + NewName;
 
   Diag << FixItHint::CreateRemoval(MatchedDecl->getSourceRange());
   Diag << FixItHint::CreateInsertion(MatchedDecl->getBeginLoc(), NewName);
-  Diag << IncludeInserter.createIncludeInsertion(
-      Result.Context->getSourceManager().getFileID(
+  Diag << createIncludeInsertion(Result.Context->getSourceManager().getFileID(
                                      MatchedCallExpr->getBeginLoc()),
                                  "<random>");
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/performance/TypePromotionInMathFnCheck.h

 //===--- TypePromotionInMathFnCheck.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_PERFORMANCE_TYPE_PROMOTION_IN_MATH_FN_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_TYPE_PROMOTION_IN_MATH_FN_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 /// Finds calls to C math library functions with implicit float to double
 /// promotions.
 ///
 /// For example, warns on ::sin(0.f), because this funciton's parameter is a
 /// double.  You probably meant to call std::sin(0.f) (in C++), or sinf(0.f) (in
 /// C).
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/performance-type-promotion-in-math-fn.html
 class TypePromotionInMathFnCheck : public ClangTidyCheck {
 public:
   TypePromotionInMathFnCheck(StringRef Name, ClangTidyContext *Context);
 
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-
-private:
-  utils::IncludeInserter IncludeInserter;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_TYPE_PROMOTION_IN_MATH_FN_H

clang-tools-extra/clang-tidy/performance/TypePromotionInMathFnCheck.cpp

if (const auto *BT = dyn_cast<BuiltinType>(&Node)) {
     return BT->getKind() == Kind;
   }
   return false;
 }
 } // anonymous namespace
 
 TypePromotionInMathFnCheck::TypePromotionInMathFnCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
-                                               utils::IncludeSorter::IS_LLVM)) {
-}
-
-void TypePromotionInMathFnCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  IncludeInserter.registerPreprocessor(PP);
-}
-
-void TypePromotionInMathFnCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
+    : ClangTidyCheck(Name, Context) {
+  registerIncludeInserter();
 }
 
 void TypePromotionInMathFnCheck::registerMatchers(MatchFinder *Finder) {
   constexpr BuiltinType::Kind IntTy = BuiltinType::Int;
   constexpr BuiltinType::Kind LongTy = BuiltinType::Long;
   constexpr BuiltinType::Kind FloatTy = BuiltinType::Float;
   constexpr BuiltinType::Kind DoubleTy = BuiltinType::Double;
   constexpr BuiltinType::Kind LongDoubleTy = BuiltinType::LongDouble;
auto Diag = diag(Call->getExprLoc(), "call to '%0' promotes float to double")
               << FixItHint::CreateReplacement(
                      Call->getCallee()->getSourceRange(), NewFnName);
 
   // Suggest including <cmath> if the function we're suggesting is declared in
   // <cmath> and it's not already included.  We never have to suggest including
   // <math.h>, because the functions we're suggesting moving away from are all
   // declared in <math.h>.
   if (FnInCmath)
-    Diag << IncludeInserter.createIncludeInsertion(
+    Diag << createIncludeInsertion(
         Result.Context->getSourceManager().getFileID(Call->getBeginLoc()),
         "<cmath>");
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.h

 //===--- UnnecessaryValueParamCheck.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_PERFORMANCE_UNNECESSARY_VALUE_PARAM_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_UNNECESSARY_VALUE_PARAM_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 #include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 /// A check that flags value parameters of expensive to copy types that
 /// can safely be converted to const references.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/performance-unnecessary-value-param.html
 class UnnecessaryValueParamCheck : public ClangTidyCheck {
 public:
   UnnecessaryValueParamCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void onEndOfTranslationUnit() override;
 
 private:
   void handleMoveFix(const ParmVarDecl &Var, const DeclRefExpr &CopyArgument,
                      const ASTContext &Context);
 
   llvm::DenseMap<const FunctionDecl *, FunctionParmMutationAnalyzer>
       MutationAnalyzers;
-  utils::IncludeInserter Inserter;
   const std::vector<std::string> AllowedTypes;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_UNNECESSARY_VALUE_PARAM_H

clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp

bool isExplicitTemplateSpecialization(const FunctionDecl &Function) {
   return false;
 }
 
 } // namespace
 
 UnnecessaryValueParamCheck::UnnecessaryValueParamCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      Inserter(Options.getLocalOrGlobal("IncludeStyle",
-                                        utils::IncludeSorter::IS_LLVM)),
       AllowedTypes(
-          utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
+          utils::options::parseStringList(Options.get("AllowedTypes", ""))) {
+  registerIncludeInserter();
+}
 
 void UnnecessaryValueParamCheck::registerMatchers(MatchFinder *Finder) {
   const auto ExpensiveValueParamDecl = parmVarDecl(
       hasType(qualType(
           hasCanonicalType(matchers::isExpensiveToCopy()),
           unless(anyOf(hasCanonicalType(referenceType()),
                        hasDeclaration(namedDecl(
                            matchers::matchesAnyListedName(AllowedTypes))))))),
for (const auto *FunctionDecl = Function; FunctionDecl != nullptr;
     if (!CurrentParam.getType().getCanonicalType().isConstQualified()) {
       if (llvm::Optional<FixItHint> Fix = utils::fixit::addQualifierToVarDecl(
               CurrentParam, *Result.Context, DeclSpec::TQ::TQ_const))
         Diag << *Fix;
     }
   }
 }
 
-void UnnecessaryValueParamCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  Inserter.registerPreprocessor(PP);
-}
-
 void UnnecessaryValueParamCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
   Options.store(Opts, "AllowedTypes",
                 utils::options::serializeStringList(AllowedTypes));
 }
 
 void UnnecessaryValueParamCheck::onEndOfTranslationUnit() {
   MutationAnalyzers.clear();
 }
 
 void UnnecessaryValueParamCheck::handleMoveFix(const ParmVarDecl &Var,
                                                const DeclRefExpr &CopyArgument,
                                                const ASTContext &Context) {
   auto Diag = diag(CopyArgument.getBeginLoc(),
                    "parameter %0 is passed by value and only copied once; "
                    "consider moving it to avoid unnecessary copies")
               << &Var;
   // Do not propose fixes in macros since we cannot place them correctly.
   if (CopyArgument.getBeginLoc().isMacroID())
     return;
   const auto &SM = Context.getSourceManager();
   auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM,
                                            Context.getLangOpts());
   Diag << FixItHint::CreateInsertion(CopyArgument.getBeginLoc(), "std::move(")
        << FixItHint::CreateInsertion(EndLoc, ")")
-       << Inserter.createIncludeInsertion(
-              SM.getFileID(CopyArgument.getBeginLoc()), "<utility>");
+       << createIncludeInsertion(SM.getFileID(CopyArgument.getBeginLoc()),
+                                 "<utility>");
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.h

 //===--- UseAnyOfAllOfCheck.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_READABILITY_USEALGORITHMCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_USEALGORITHMCHECK_H
 
 #include "../ClangTidyCheck.h"
-#include "../utils/IncludeInserter.h"
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 /// Finds ranged-based for loops that can be replaced by a call to std::any_of
 /// or std::all_of.
 ///

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

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 add_clang_library(clangTidyUtils
   Aliasing.cpp
   ASTUtils.cpp
   DeclRefExprUtils.cpp
   ExceptionAnalyzer.cpp
   ExprSequence.cpp
   FileExtensionsUtils.cpp
   FixItHintUtils.cpp
   HeaderGuard.cpp
-  IncludeInserter.cpp
-  IncludeSorter.cpp
   LexerUtils.cpp
   NamespaceAliaser.cpp
   OptionsUtils.cpp
   RenamerClangTidyCheck.cpp
   TransformerClangTidyCheck.cpp
   TypeTraits.cpp
   UsingInserter.cpp
 

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

 //===---------- TransformerClangTidyCheck.h - 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_TRANSFORMER_CLANG_TIDY_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_TRANSFORMER_CLANG_TIDY_CHECK_H
 
 #include "../ClangTidyCheck.h"
-#include "IncludeInserter.h"
-#include "IncludeSorter.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Tooling/Transformer/Transformer.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
 /// A base class for defining a ClangTidy check based on a `RewriteRule`.
 //
 // For example, given a rule `MyCheckAsRewriteRule`, one can define a tidy check
 // as follows:
 //
 // class MyCheck : public TransformerClangTidyCheck {
 //  public:
 //   MyCheck(StringRef Name, ClangTidyContext *Context)
 //       : TransformerClangTidyCheck(MyCheckAsRewriteRule, Name, Context) {}
 // };
 //
-// `TransformerClangTidyCheck` recognizes this clang-tidy option:
-//
-//  * IncludeStyle. A string specifying which file naming convention is used by
-//      the source code, 'llvm' or 'google'.  Default is 'llvm'. The naming
-//      convention influences how canonical headers are distinguished from other
-//      includes.
 class TransformerClangTidyCheck : public ClangTidyCheck {
 public:
   TransformerClangTidyCheck(StringRef Name, ClangTidyContext *Context);
 
   /// DEPRECATED: prefer the two argument constructor in conjunction with
   /// \c setRule.
   ///
   /// \p MakeRule generates the rewrite rule to be used by the check, based on
   /// the given language and clang-tidy options. It can return \c None to handle
   /// cases where the options disable the check.
   ///
   /// See \c setRule for constraints on the rule.
   TransformerClangTidyCheck(std::function<Optional<transformer::RewriteRule>(
                                 const LangOptions &, const OptionsView &)>
                                 MakeRule,
                             StringRef Name, ClangTidyContext *Context);
 
   /// Convenience overload of the constructor when the rule doesn't have any
   /// dependencies.
   TransformerClangTidyCheck(transformer::RewriteRule R, StringRef Name,
                             ClangTidyContext *Context);
 
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) final;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) final;
 
-  /// Derived classes that override this function should call this method from
-  /// the overridden method.
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
-
   /// Set the rule that this check implements.  All cases in the rule must have
   /// a non-null \c Explanation, even though \c Explanation is optional for
   /// RewriteRule in general. Because the primary purpose of clang-tidy checks
   /// is to provide users with diagnostics, we assume that a missing explanation
   /// is a bug.  If no explanation is desired, indicate that explicitly (for
   /// example, by passing `text("no explanation")` to `makeRule` as the
   /// `Explanation` argument).
   void setRule(transformer::RewriteRule R);
 
 private:
   transformer::RewriteRule Rule;
-  IncludeInserter Inserter;
 };
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_TRANSFORMER_CLANG_TIDY_CHECK_H

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

 static void verifyRule(const RewriteRule &Rule) {
   assert(llvm::all_of(Rule.Cases, hasExplanation) &&
          "clang-tidy checks must have an explanation by default;"
          " explicitly provide an empty explanation if none is desired");
 }
 
 TransformerClangTidyCheck::TransformerClangTidyCheck(StringRef Name,
                                                      ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      Inserter(
-          Options.getLocalOrGlobal("IncludeStyle", IncludeSorter::IS_LLVM)) {}
-
+    : ClangTidyCheck(Name, Context) {
+  registerIncludeInserter();
+}
 // This constructor cannot dispatch to the simpler one (below), because, in
 // order to get meaningful results from `getLangOpts` and `Options`, we need the
 // `ClangTidyCheck()` constructor to have been called. If we were to dispatch,
 // we would be accessing `getLangOpts` and `Options` before the underlying
 // `ClangTidyCheck` instance was properly initialized.
 TransformerClangTidyCheck::TransformerClangTidyCheck(
     std::function<Optional<RewriteRule>(const LangOptions &,
                                         const OptionsView &)>
         MakeRule,
     StringRef Name, ClangTidyContext *Context)
     : TransformerClangTidyCheck(Name, Context) {
+  registerIncludeInserter();
   if (Optional<RewriteRule> R = MakeRule(getLangOpts(), Options))
     setRule(std::move(*R));
 }
 
 TransformerClangTidyCheck::TransformerClangTidyCheck(RewriteRule R,
                                                      StringRef Name,
                                                      ClangTidyContext *Context)
     : TransformerClangTidyCheck(Name, Context) {
+  registerIncludeInserter();
   setRule(std::move(R));
 }
 
 void TransformerClangTidyCheck::setRule(transformer::RewriteRule R) {
   verifyRule(R);
   Rule = std::move(R);
 }
 
-void TransformerClangTidyCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  Inserter.registerPreprocessor(PP);
-}
-
 void TransformerClangTidyCheck::registerMatchers(
     ast_matchers::MatchFinder *Finder) {
   if (!Rule.Cases.empty())
     for (auto &Matcher : transformer::detail::buildMatchers(Rule))
       Finder->addDynamicMatcher(Matcher, this);
 }
 
 void TransformerClangTidyCheck::check(
void TransformerClangTidyCheck::check(
   // Associate the diagnostic with the location of the first change.
   DiagnosticBuilder Diag = diag((*Edits)[0].Range.getBegin(), *Explanation);
   for (const auto &T : *Edits)
     switch (T.Kind) {
     case transformer::EditKind::Range:
       Diag << FixItHint::CreateReplacement(T.Range, T.Replacement);
       break;
     case transformer::EditKind::AddInclude:
-      Diag << Inserter.createIncludeInsertion(
+      Diag << createIncludeInsertion(
           Result.SourceManager->getFileID(T.Range.getBegin()), T.Replacement);
       break;
     }
 }
 
-void TransformerClangTidyCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
-}
-
 } // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clangd/ParsedAST.cpp

if (PreserveDiags) {
     CTContext->setDiagnosticsEngine(&Clang->getDiagnostics());
     CTContext->setASTContext(&Clang->getASTContext());
     CTContext->setCurrentFile(Filename);
     CTChecks = CTFactories.createChecks(CTContext.getPointer());
     llvm::erase_if(CTChecks, [&](const auto &Check) {
       return !Check->isLanguageVersionSupported(CTContext->getLangOpts());
     });
     Preprocessor *PP = &Clang->getPreprocessor();
+    if (CTContext->hasIncludeInserter())
+      CTContext->getIncludeInserter().registerPreprocessor(PP);
     for (const auto &Check : CTChecks) {
       Check->registerPPCallbacks(Clang->getSourceManager(), PP, PP);
       Check->registerMatchers(&CTFinder);
     }
 
     const Config &Cfg = Config::current();
     ASTDiags.setLevelAdjuster([&](DiagnosticsEngine::Level DiagLevel,
                                   const clang::Diagnostic &Info) {

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

std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
 
     Preprocessor *PP = &Compiler.getPreprocessor();
 
     // Checks must be created here, _after_ `Context` has been initialized, so
     // that check constructors can access the context (for example, through
     // `getLangOpts()`).
     CheckFactory<CheckTypes...>::createChecks(&Context, Checks);
     assert(!Checks.empty() && "No checks created");
+
+    if (Context.hasIncludeInserter())
+      Context.getIncludeInserter().registerPreprocessor(PP);
+
     for (auto &Check : Checks) {
       assert(Check.get() && "Checks can't be null");
       if (!Check->isLanguageVersionSupported(Context.getLangOpts()))
         continue;
       Check->registerMatchers(&Finder);
       Check->registerPPCallbacks(Compiler.getSourceManager(), PP, PP);
     }
     return Finder.newASTConsumer();

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

 //===---- IncludeInserterTest.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 "../clang-tidy/utils/IncludeInserter.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "ClangTidyTest.h"
 #include "gtest/gtest.h"
 
 // FIXME: Canonicalize paths correctly on windows.
 // Currently, adding virtual files will canonicalize the paths before
 // storing the virtual entries.
 // When resolving virtual entries in the FileManager, the paths (for
 // example coming from a #include directive) are not canonicalized
 // to native paths; thus, the virtual file is not found.
 // This needs to be fixed in the FileManager before we can make
 // clang-tidy tests work.
 #if !defined(_WIN32)
 
 namespace clang {
 namespace tidy {
 namespace {
 
 class IncludeInserterCheckBase : public ClangTidyCheck {
 public:
-  IncludeInserterCheckBase(StringRef CheckName, ClangTidyContext *Context,
-                           utils::IncludeSorter::IncludeStyle Style =
-                               utils::IncludeSorter::IS_Google)
-      : ClangTidyCheck(CheckName, Context), Inserter(Style) {}
-
-  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                           Preprocessor *ModuleExpanderPP) override {
-    Inserter.registerPreprocessor(PP);
+  IncludeInserterCheckBase(
+      StringRef CheckName, ClangTidyContext *Context,
+      IncludeSorter::IncludeStyle Style = IncludeSorter::IS_Google)
+      : ClangTidyCheck(CheckName, Context) {
+    Context->registerIncludeInserter(Style);
   }
 
   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
     Finder->addMatcher(ast_matchers::declStmt().bind("stmt"), this);
   }
 
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
     auto Diag = diag(Result.Nodes.getNodeAs<DeclStmt>("stmt")->getBeginLoc(),
                      "foo, bar");
     for (StringRef Header : headersToInclude()) {
-      Diag << Inserter.createMainFileIncludeInsertion(Header);
+      Diag << createMainFileIncludeInsertion(Header);
     }
   }
 
   virtual std::vector<StringRef> headersToInclude() const = 0;
-
-  utils::IncludeInserter Inserter;
 };
 
 class NonSystemHeaderInserterCheck : public IncludeInserterCheckBase {
 public:
   NonSystemHeaderInserterCheck(StringRef CheckName, ClangTidyContext *Context)
       : IncludeInserterCheckBase(CheckName, Context) {}
 
   std::vector<StringRef> headersToInclude() const override {
public:
   }
 };
 
 class ObjCEarlyInAlphabetHeaderInserterCheck : public IncludeInserterCheckBase {
 public:
   ObjCEarlyInAlphabetHeaderInserterCheck(StringRef CheckName,
                                          ClangTidyContext *Context)
       : IncludeInserterCheckBase(CheckName, Context,
-                                 utils::IncludeSorter::IS_Google_ObjC) {}
+                                 IncludeSorter::IS_Google_ObjC) {}
 
   std::vector<StringRef> headersToInclude() const override {
     return {"a/header.h"};
   }
 };
 
 class ObjCCategoryHeaderInserterCheck : public IncludeInserterCheckBase {
 public:
   ObjCCategoryHeaderInserterCheck(StringRef CheckName,
                                   ClangTidyContext *Context)
       : IncludeInserterCheckBase(CheckName, Context,
-                                 utils::IncludeSorter::IS_Google_ObjC) {}
+                                 IncludeSorter::IS_Google_ObjC) {}
 
   std::vector<StringRef> headersToInclude() const override {
     return {"top_level_test_header+foo.h"};
   }
 };
 
 class ObjCGeneratedHeaderInserterCheck : public IncludeInserterCheckBase {
 public:
   ObjCGeneratedHeaderInserterCheck(StringRef CheckName,
                                    ClangTidyContext *Context)
       : IncludeInserterCheckBase(CheckName, Context,
-                                 utils::IncludeSorter::IS_Google_ObjC) {}
+                                 IncludeSorter::IS_Google_ObjC) {}
 
   std::vector<StringRef> headersToInclude() const override {
     return {"clang_tidy/tests/generated_file.proto.h"};
   }
 };
 
 template <typename Check>
 std::string runCheckOnCode(StringRef Code, StringRef Filename) {

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

static RewriteRule rule() {
     return Rule;
   }
 
 public:
   IncludeOrderCheck(StringRef Name, ClangTidyContext *Context)
       : TransformerClangTidyCheck(rule(), Name, Context) {}
 };
 
-TEST(TransformerClangTidyCheckTest, AddIncludeObeysSortStyleLocalOption) {
-  std::string Input = R"cc(#include "input.h"
-int h(int x) { return 3; })cc";
-
-  std::string TreatsAsLibraryHeader = R"cc(#include "input.h"
-
-#include "bar.h"
-int h(int x) { return 5; })cc";
-
-  std::string TreatsAsNormalHeader = R"cc(#include "bar.h"
-#include "input.h"
-int h(int x) { return 5; })cc";
-
-  ClangTidyOptions Options;
-  std::map<StringRef, StringRef> PathsToContent = {{"input.h", "\n"}};
-  Options.CheckOptions["test-check-0.IncludeStyle"] = "llvm";
-  EXPECT_EQ(TreatsAsLibraryHeader, test::runCheckOnCode<IncludeOrderCheck>(
-                                       Input, nullptr, "inputTest.cpp", None,
-                                       Options, PathsToContent));
-  EXPECT_EQ(TreatsAsNormalHeader, test::runCheckOnCode<IncludeOrderCheck>(
-                                      Input, nullptr, "input_test.cpp", None,
-                                      Options, PathsToContent));
-
-  Options.CheckOptions["test-check-0.IncludeStyle"] = "google";
-  EXPECT_EQ(TreatsAsNormalHeader,
-            test::runCheckOnCode<IncludeOrderCheck>(
-                Input, nullptr, "inputTest.cc", None, Options, PathsToContent));
-  EXPECT_EQ(TreatsAsLibraryHeader, test::runCheckOnCode<IncludeOrderCheck>(
-                                       Input, nullptr, "input_test.cc", None,
-                                       Options, PathsToContent));
-}
-
 TEST(TransformerClangTidyCheckTest, AddIncludeObeysSortStyleGlobalOption) {
   std::string Input = R"cc(#include "input.h"
 int h(int x) { return 3; })cc";
 
   std::string TreatsAsLibraryHeader = R"cc(#include "input.h"
 
 #include "bar.h"
 int h(int x) { return 5; })cc";