[clang-tidy] Extract Class IncluderClangTidyCheck

[LegalizeAdulthood]

Summary

IncluderClangTidyCheck is a base class for checks that
want to insert include files as part of their fixits.

IncluderClangTidyCheck::storeOptions should be called
first by any derived classes that override storeOptions.

IncluderClangTidyCheck::registerPPCallbacks should be
called first by any derived classes that override
registerPPCallbacks and perform additional preprocessor
logic.

Switch the following classes to use IncluderClangTidyCheck:

• abseil::StringFindStartswithCheck
• bugprone::ImplicitWideningOfMultiplicationResultCheck
• cppcoreguidelines::InitVariablesCheck
• cppcoreguidelines::ProBoundsCOnstantArrayIndexCheck
• misc::UniqueptrResetReleaseCheck
• modernize::LoopConvertCheck
• modernize::MakeSmartPtrCheck
• modernize::PassByValueCheck
• modernize::ReplaceAutoPtrCheck
• modernize::ReplaceRandomShuffleCheck
• performance::TypePromotionInMathFnCheck
• performance::UnnecessaryValueParamCheck
• utils::TransformerClangTidyCheck

[ymandel]

Overall, this change looks good and makes sense. But, it doesn't scale past 1 feature, which makes me a bit hesitant. I don't have another example offhand, but include-inserter is an arbitrary feature and I don't love conflating feature addition with the class hierarchy. Might there be some other way to get the benefits of saving implementers the cut and paste (and bug-prone code that comes with it) without changing the class hierarchy?

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

13

can you delete this?

[LegalizeAdulthood]

In D117129#3238433, @ymandel wrote:

Overall, this change looks good and makes sense. But, it doesn't scale past 1 feature
[...] Might there be some other way to get the benefits of saving implementers the
cut and paste (and bug-prone code that comes with it) without changing the class
hierarchy?

Maybe some sort of mix-in approach or "implementation inheritance" as they say?

[LegalizeAdulthood]

Another option would be to migrate this to ClangTidyCheck itself
and add a flag/option passed to the ClangTidyCheck c'tor to opt-in
to the feature?

[ymandel]

In D117129#3238441, @LegalizeAdulthood wrote:

Another option would be to migrate this to ClangTidyCheck itself
and add a flag/option passed to the ClangTidyCheck c'tor to opt-in
to the feature?

Right, I was wondering about this. The feature is pretty core to handling C++ files and widely used, so it may warrant that. But, I don't know who the right reviewers are to ask about making changes to the ClangTidyCheck class.

[njames93]

In D117129#3238441, @LegalizeAdulthood wrote:

Another option would be to migrate this to ClangTidyCheck itself
and add a flag/option passed to the ClangTidyCheck c'tor to opt-in
to the feature?

I feel that this direction is much better, Its something I wanted to introduce a while back, but my work was getting in the way.
My proposed idea was putting the IncludeInserter instance inside the ClangTidyContext, but then only registering it if any checks actually want to use it.

[LegalizeAdulthood]

In D117129#3239143, @njames93 wrote:

My proposed idea was putting the IncludeInserter instance
inside the ClangTidyContext, but then only registering it if
any checks actually want to use it.

Use of the IncludeInserter would be signaled by an argument
to the ctor fo r`ClangTidyCheck` in the c'tor for the derived
class?

[njames93]

In D117129#3239514, @LegalizeAdulthood wrote:

In D117129#3239143, @njames93 wrote:

My proposed idea was putting the IncludeInserter instance
inside the ClangTidyContext, but then only registering it if
any checks actually want to use it.

Use of the IncludeInserter would be signaled by an argument
to the ctor fo r`ClangTidyCheck` in the c'tor for the derived
class?

There is a hurdle to overcome with this, Currently each check can have its own include style - which doesn't really make sense. Hopefully people actually just use the global version of the option instead.
However if we were to coalesce all checks to use the same IncludeInserter, we would have to force clang-tidy to just read the global version.
Going this route it'd be best if we warned on configs that specify their own IncludeStyle. I've created a draft implementation above, definitely needs work though.

[LegalizeAdulthood]

Eliminate an intermediate class and move the IncludeInserter
functionality into ClangTidyCheck with an enum to indicate
opt-in to use of the IncludeInserter.

[LegalizeAdulthood]

In D117129#3246403, @njames93 wrote:

There is a hurdle to overcome with this, Currently each check can have its own include style - which doesn't really make sense. Hopefully people actually just use the global version of the option instead.
However if we were to coalesce all checks to use the same IncludeInserter, we would have to force clang-tidy to just read the global version.
Going this route it'd be best if we warned on configs that specify their own IncludeStyle. I've created a draft implementation above, definitely needs work though.

I pushed the functionality down into ClangTidyCheck
instead of introducing an intermediate class. Does this
address your concern?

[njames93]

In D117129#3246610, @LegalizeAdulthood wrote:

In D117129#3246403, @njames93 wrote:

I pushed the functionality down into ClangTidyCheck
instead of introducing an intermediate class. Does this
address your concern?

This is a step backwards. Now every check is paying for an IncludeInserter that most never use. I've put D117409 up that, despite being a little rough round the edges, solves the problem in a way where there is only 1 shared Inserter.

[LegalizeAdulthood]

I added some comments on the other review.

Is constructing an IncludeInserter particularly expensive?
I'm just curious.

[aaron.ballman]

In D117129#3246403, @njames93 wrote:

In D117129#3239514, @LegalizeAdulthood wrote:

In D117129#3239143, @njames93 wrote:

My proposed idea was putting the IncludeInserter instance
inside the ClangTidyContext, but then only registering it if
any checks actually want to use it.

Use of the IncludeInserter would be signaled by an argument
to the ctor fo r`ClangTidyCheck` in the c'tor for the derived
class?

There is a hurdle to overcome with this, Currently each check can have its own include style - which doesn't really make sense.

Hmm, I think it could make sense for sizeable projects that have components written by separate teams. Granted, I think it's a bit of a strange situation, but I wouldn't go so far as to say it doesn't make sense.

[njames93]

In D117129#3251577, @aaron.ballman wrote:

In D117129#3246403, @njames93 wrote:

There is a hurdle to overcome with this, Currently each check can have its own include style - which doesn't really make sense.

Hmm, I think it could make sense for sizeable projects that have components written by separate teams. Granted, I think it's a bit of a strange situation, but I wouldn't go so far as to say it doesn't make sense.

I'm not saying that different teams having different include styles doesn't make sense. I'm saying one translation unit that runs multiple checks with IncludeInserters where they have different styles doesn't make sense.
That could result in each check trying to create includes in the same file, but assuming a different include style.

[aaron.ballman]

In D117129#3251705, @njames93 wrote:

In D117129#3251577, @aaron.ballman wrote:

In D117129#3246403, @njames93 wrote:

There is a hurdle to overcome with this, Currently each check can have its own include style - which doesn't really make sense.

Hmm, I think it could make sense for sizeable projects that have components written by separate teams. Granted, I think it's a bit of a strange situation, but I wouldn't go so far as to say it doesn't make sense.

I'm not saying that different teams having different include styles doesn't make sense. I'm saying one translation unit that runs multiple checks with IncludeInserters where they have different styles doesn't make sense.
That could result in each check trying to create includes in the same file, but assuming a different include style.

Oh, I see what you mean now: include sort orders that battle one another. Yeah, that is a situation that seems worth warning the user about. Thanks for clarifying!

[LegalizeAdulthood]

Abandoning this in favor of https://reviews.llvm.org/D117409

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

 //===--- ClangTidyCheck.h - clang-tidy --------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYCHECK_H
 
 #include "ClangTidyDiagnosticConsumer.h"
+
 #include "ClangTidyOptions.h"
+#include "utils/IncludeInserter.h"
+
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/Diagnostic.h"
 #include "llvm/ADT/Optional.h"
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace clang {
 
 class CompilerInstance;
 class SourceManager;
 
 namespace tidy {
 
-/// This class should be specialized by any enum type that needs to be converted
-/// to and from an \ref llvm::StringRef.
-template <class T> struct OptionEnumMapping {
-  // Specializations of this struct must implement this function.
-  static ArrayRef<std::pair<T, StringRef>> getEnumMapping() = delete;
-};
-
 /// Base class for all clang-tidy checks.
 ///
 /// To implement a ``ClangTidyCheck``, write a subclass and override some of the
 /// base class's methods. E.g. to implement a check that validates namespace
 /// declarations, override ``registerMatchers``:
 ///
 /// ~~~{.cpp}
 /// void registerMatchers(ast_matchers::MatchFinder *Finder) override {

 /// useful/necessary.
 class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
 public:
   /// Initializes the check with \p CheckName and \p Context.
   ///
   /// Derived classes must implement the constructor with this signature or
   /// delegate it. If a check needs to read options, it can do this in the
   /// constructor using the Options.get() methods below.
-  ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context);
+  ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context,
+                 CheckFeatures OptionalFeatures = CheckFeatures::None);
 
   /// Override this to disable registering matchers and PP callbacks if an
   /// invalid language version is being used.
   ///
   /// For example if a check is examining overloaded functions then this should
   /// be overridden to return false when the CPlusPlus flag is not set in
   /// \p LangOpts.
   virtual bool isLanguageVersionSupported(const LangOptions &LangOpts) const {
public:
   ///  - PP is the real Preprocessor. It doesn't walk into modular #includes and
   ///    thus doesn't generate PPCallbacks for their contents.
   ///  - ModuleExpanderPP preprocesses the whole translation unit in the
   ///    non-modular mode, which allows it to generate PPCallbacks not only for
   ///    the main file and textual headers, but also for all transitively
   ///    included modular headers when the analysis runs with modules enabled.
   ///    When modules are not enabled ModuleExpanderPP just points to the real
   ///    preprocessor.
+  ///
+  /// Derived classes that override this function should call this method from
+  /// the overridden method.
   virtual void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
-                                   Preprocessor *ModuleExpanderPP) {}
+                                   Preprocessor *ModuleExpanderPP);
 
   /// Override this to register AST matchers with \p Finder.
   ///
   /// This should be used by clang-tidy checks that analyze code properties that
   /// dependent on AST knowledge.
   ///
   /// You can register as many matchers as necessary with \p Finder. Usually,
   /// "this" will be used as callback, but you can also specify other callback
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;
 
+  /// Creates a fixit that inserts an include directive in the given file.
+  Optional<FixItHint> createIncludeInsertion(FileID FileID, StringRef Header);
+
+  /// Creates a fixit that inserts an include directive in the file associated
+  /// with the given location.
+  Optional<FixItHint> createIncludeInsertion(SourceLocation Loc,
+                                             StringRef Header);
+
+  /// Creates a fixit that inserts an include directive in the main file.
+  Optional<FixItHint> createMainFileIncludeInsertion(StringRef Header);
+
   /// 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) {}
+  ///
+  /// Derived classes that override this function should call this method from
+  /// the overridden method.
+  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.
   class OptionsView {
     void diagnoseBadIntegerOption(const Twine &Lookup,
typeEraseMapping() const {
                             MappedItem.second);
       }
       return Result;
     }
 
     void storeInt(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
                   int64_t Value) const;
 
-
     std::string NamePrefix;
     const ClangTidyOptions::OptionMap &CheckOptions;
     ClangTidyContext *Context;
   };
 
-private:
-  void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
-  StringRef getID() const override { return CheckName; }
-  std::string CheckName;
-  ClangTidyContext *Context;
-
 protected:
   OptionsView Options;
   /// Returns the main file name of the current translation unit.
   StringRef getCurrentMainFile() const { return Context->getCurrentFile(); }
   /// Returns the language options from the context.
   const LangOptions &getLangOpts() const { return Context->getLangOpts(); }
+
+private:
+  void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  StringRef getID() const override { return CheckName; }
+  bool useIncludeInserter() const {
+    return (OptionalFeatures & CheckFeatures::UseIncludeInserter) != 0;
+  }
+
+  std::string CheckName;
+  ClangTidyContext *Context;
+  CheckFeatures OptionalFeatures;
+  utils::IncludeInserter IncludeInserter;
+  const SourceManager *SourceMgr = nullptr;
 };
 
 /// Read a named option from the ``Context`` and parse it as a bool.
 ///
 /// Reads the option with the check-local name \p LocalName from the
 /// ``CheckOptions``. If the corresponding key is not present, return
 /// ``None``.
 ///

 
 /// Stores an option with the check-local name \p LocalName with
 /// bool value \p Value to \p Options.
 template <>
 void ClangTidyCheck::OptionsView::store<bool>(
     ClangTidyOptions::OptionMap &Options, StringRef LocalName,
     bool Value) const;
 
-
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYCHECK_H

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

 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/YAMLParser.h"
 
 namespace clang {
 namespace tidy {
 
-ClangTidyCheck::ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context)
+ClangTidyCheck::ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context,
+                               CheckFeatures OptionalFeatures)
     : CheckName(CheckName), Context(Context),
-      Options(CheckName, Context->getOptions().CheckOptions, Context) {
+      Options(CheckName, Context->getOptions().CheckOptions, Context),
+      OptionalFeatures(OptionalFeatures),
+      IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
+                                               utils::IncludeSorter::IS_LLVM)) {
   assert(Context != nullptr);
   assert(!CheckName.empty());
 }
 
 DiagnosticBuilder ClangTidyCheck::diag(SourceLocation Loc, StringRef Message,
                                        DiagnosticIDs::Level Level) {
   return Context->diag(CheckName, Loc, Message, Level);
 }
 
 DiagnosticBuilder ClangTidyCheck::diag(StringRef Message,
                                        DiagnosticIDs::Level Level) {
   return Context->diag(CheckName, Message, Level);
 }
 
 DiagnosticBuilder
 ClangTidyCheck::configurationDiag(StringRef Description,
                                   DiagnosticIDs::Level Level) const {
   return Context->configurationDiag(Description, Level);
 }
 
+void ClangTidyCheck::registerPPCallbacks(const SourceManager &SM,
+                                         Preprocessor *PP,
+                                         Preprocessor *ModuleExpanderPP) {
+  if (useIncludeInserter()) {
+    SourceMgr = &SM;
+    IncludeInserter.registerPreprocessor(PP);
+  }
+}
+
+void ClangTidyCheck::storeOptions(ClangTidyOptions::OptionMap &Options) {
+  if (useIncludeInserter())
+    this->Options.store(Options, "IncludeStyle", IncludeInserter.getStyle());
+}
+
+Optional<FixItHint> ClangTidyCheck::createIncludeInsertion(FileID FileID,
+                                                           StringRef Header) {
+  assert(useIncludeInserter());
+  return IncludeInserter.createIncludeInsertion(FileID, Header);
+}
+
+Optional<FixItHint> ClangTidyCheck::createIncludeInsertion(SourceLocation Loc,
+                                                           StringRef Header) {
+  assert(useIncludeInserter());
+  return createIncludeInsertion(SourceMgr->getFileID(Loc), Header);
+}
+
+Optional<FixItHint>
+ClangTidyCheck::createMainFileIncludeInsertion(StringRef Header) {
+  assert(useIncludeInserter());
+  return IncludeInserter.createMainFileIncludeInsertion(Header);
+}
+
 void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
   // For historical reasons, checks don't implement the MatchFinder run()
   // callback directly. We keep the run()/check() distinction to avoid interface
   // churn, and to allow us to add cross-cutting logic in the future.
   check(Result);
 }
 
 ClangTidyCheck::OptionsView::OptionsView(
     StringRef CheckName, const ClangTidyOptions::OptionMap &CheckOptions,
     ClangTidyContext *Context)
     : NamePrefix(CheckName.str() + "."), CheckOptions(CheckOptions),
       Context(Context) {}
 
 llvm::Optional<std::string>
 ClangTidyCheck::OptionsView::get(StringRef LocalName) const {
   const auto &Iter = CheckOptions.find(NamePrefix + LocalName.str());
   if (Iter != CheckOptions.end())
     return Iter->getValue().Value;
   return None;
 }
 
 static ClangTidyOptions::OptionMap::const_iterator
-findPriorityOption(const ClangTidyOptions::OptionMap &Options, StringRef NamePrefix,
-          StringRef LocalName) {
+findPriorityOption(const ClangTidyOptions::OptionMap &Options,
+                   StringRef NamePrefix, StringRef LocalName) {
   auto IterLocal = Options.find((NamePrefix + LocalName).str());
   auto IterGlobal = Options.find(LocalName.str());
   if (IterLocal == Options.end())
     return IterGlobal;
   if (IterGlobal == Options.end())
     return IterLocal;
   if (IterLocal->getValue().Priority >= IterGlobal->getValue().Priority)
     return IterLocal;

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

struct ClangTidyStats {
   unsigned ErrorsIgnoredLineFilter = 0;
 
   unsigned errorsIgnored() const {
     return ErrorsIgnoredNOLINT + ErrorsIgnoredCheckFilter +
            ErrorsIgnoredNonUserCode + ErrorsIgnoredLineFilter;
   }
 };
 
+enum class CheckFeatures {
+  None = 0,
+  EnableAnalyzerAlphaCheckers = 0x1,
+  UseIncludeInserter = 0x2
+};
+inline CheckFeatures operator&(CheckFeatures LHS, CheckFeatures RHS) {
+  return static_cast<CheckFeatures>(static_cast<int>(LHS) &
+                                    static_cast<int>(RHS));
+}
+inline bool operator!=(CheckFeatures LHS, int RHS) {
+  return static_cast<int>(LHS) != RHS;
+}
+
 /// Every \c ClangTidyCheck reports errors through a \c DiagnosticsEngine
 /// provided by this context.
 ///
 /// A \c ClangTidyCheck always has access to the active context to report
 /// warnings like:
 /// \code
 /// Context->Diag(Loc, "Single-argument constructors must be explicit")
 ///     << FixItHint::CreateInsertion(Loc, "explicit ");

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

+//===--- ClangTidyCheck.h - clang-tidy --------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OPTIONENUMMAPPING_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OPTIONENUMMAPPING_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
+#include <utility>
+
+namespace clang {
+namespace tidy {
+
+/// This class should be specialized by any enum type that needs to be converted
+/// to and from an \ref llvm::StringRef.
+template <class T> struct OptionEnumMapping {
+  // Specializations of this struct must implement this function.
+  static ArrayRef<std::pair<T, StringRef>> getEnumMapping() = delete;
+};
+
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OPTIONENUMMAPPING_H

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;
+  StringFindStartswithCheck(StringRef CheckName, ClangTidyContext *Context);
+  ~StringFindStartswithCheck() override = default;
+
   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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace abseil {
 
 StringFindStartswithCheck::StringFindStartswithCheck(StringRef Name,
                                                      ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
+    : ClangTidyCheck(Name, Context, CheckFeatures::UseIncludeInserter),
       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")) {}
 
 void StringFindStartswithCheck::registerMatchers(MatchFinder *Finder) {
   auto ZeroLiteral = integerLiteral(equals(0));
   auto StringClassMatcher = cxxRecordDecl(hasAnyName(SmallVector<StringRef, 4>(
       StringLikeClasses.begin(), StringLikeClasses.end())));
   auto StringType = hasUnqualifiedDesugaredType(
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(
-      Source.getFileID(ComparisonExpr->getBeginLoc()),
+  Diagnostic << createIncludeInsertion(ComparisonExpr->getBeginLoc(),
                                        AbseilStringsMatchHeader);
 }
 
-void StringFindStartswithCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  IncludeInserter.registerPreprocessor(PP);
-}
-
 void StringFindStartswithCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
+  ClangTidyCheck::storeOptions(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 {
+public:
+  ImplicitWideningOfMultiplicationResultCheck(StringRef Name,
+                                              ClangTidyContext *Context);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
   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

if (!BO || BO->getOpcode() != BO_Mul)
     // FIXME: what about:  long r = int(x) + (int(y) * int(z));  ?
     return nullptr;
   return BO->getLHS()->IgnoreParens();
 }
 
 ImplicitWideningOfMultiplicationResultCheck::
     ImplicitWideningOfMultiplicationResultCheck(StringRef Name,
                                                 ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
+    : ClangTidyCheck(Name, Context, CheckFeatures::UseIncludeInserter),
       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)) {}
 
 void ImplicitWideningOfMultiplicationResultCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
+  ClangTidyCheck::storeOptions(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(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 cppcoreguidelines {
 
 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)),
+    : ClangTidyCheck(Name, Context, CheckFeatures::UseIncludeInserter),
       MathHeader(Options.get("MathHeader", "<math.h>")) {}
 
 void InitVariablesCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
+  ClangTidyCheck::storeOptions(Opts);
   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:
   //
   // TYPENAME_FROM_MACRO var;
   //
   // but not if the entire declaration comes from
   // one:
if (InitializationString) {
     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(
-          Source.getFileID(MatchedDecl->getBeginLoc()), MathHeader);
-    }
+    if (AddMathInclude)
+      Diagnostic << createIncludeInsertion(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;
+
+private:
+  const std::string GslHeader;
 };
 
 } // 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, CheckFeatures::UseIncludeInserter),
+      GslHeader(Options.get("GslHeader", "")) {}
 
 void ProBoundsConstantArrayIndexCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
+  ClangTidyCheck::storeOptions(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, CheckFeatures::UseIncludeInserter) {}
 
 void UniqueptrResetReleaseCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       cxxMemberCallExpr(
           callee(memberExpr(
                      member(cxxMethodDecl(
                          hasName("reset"),
                          ofClass(cxxRecordDecl(hasName("::std::unique_ptr"),
D << FixItHint::CreateReplacement(
            CharSourceRange::getCharRange(ResetMember->getOperatorLoc(),
                                          Right->getBeginLoc()),
            AssignmentText)
     << FixItHint::CreateReplacement(
            CharSourceRange::getTokenRange(ReleaseMember->getOperatorLoc(),
                                           ResetCall->getEndLoc()),
            TrailingText);
   if (NeedsUtilityInclude)
-    D << Inserter.createIncludeInsertion(
-        Result.SourceManager->getFileID(ResetMember->getBeginLoc()),
-        "<utility>");
+    D << createIncludeInsertion(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

static bool containerIsConst(const Expr *ContainerExpr, bool Dereference) {
   return false;
 }
 
 LoopConvertCheck::RangeDescriptor::RangeDescriptor()
     : ContainerNeedsDereference(false), DerefByConstRef(false),
       DerefByValue(false), NeedsReverseCall(false) {}
 
 LoopConvertCheck::LoopConvertCheck(StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context), TUInfo(new TUTrackingInfo),
+    : ClangTidyCheck(Name, Context, CheckFeatures::UseIncludeInserter),
+      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", "")) {
-
   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) {
+  ClangTidyCheck::storeOptions(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(
-            Context->getSourceManager().getFileID(Loop->getBeginLoc()),
-            getReverseHeader()))
+    if (Optional<FixItHint> Insertion =
+            createIncludeInsertion(Loop->getBeginLoc(), getReverseHeader()))
       FixIts.push_back(*Insertion);
   }
   diag(Loop->getForLoc(), "use range-based for loop instead") << FixIts;
   TUInfo->getGeneratedDecls().insert(make_pair(Loop, VarName));
 }
 
 /// Returns a string which refers to the container iterated over.
 StringRef LoopConvertCheck::getContainerString(ASTContext *Context,
                                                const ForStmt *Loop,
                                                const Expr *ContainerExpr) {
   StringRef ContainerString;
   ContainerExpr = ContainerExpr->IgnoreParenImpCasts();
   if (isa<CXXThisExpr>(ContainerExpr)) {
     ContainerString = "this";
   } else {
     // For CXXOperatorCallExpr such as vector_ptr->size() we want the class
     // object vector_ptr, but for vector[2] we need the whole expression.
-    if (const auto* E = dyn_cast<CXXOperatorCallExpr>(ContainerExpr))
+    if (const auto *E = dyn_cast<CXXOperatorCallExpr>(ContainerExpr))
       if (E->getOperator() != OO_Subscript)
         ContainerExpr = E->getArg(0);
     ContainerString =
         getStringFromRange(Context->getSourceManager(), Context->getLangOpts(),
                            ContainerExpr->getSourceRange());
   }
 
   return ContainerString;

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)),
+    : ClangTidyCheck(Name, Context, CheckFeatures::UseIncludeInserter),
       MakeSmartPtrFunctionHeader(
           Options.get("MakeSmartPtrFunctionHeader", "<memory>")),
       MakeSmartPtrFunctionName(
           Options.get("MakeSmartPtrFunction", MakeSmartPtrFunctionName)),
       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)),
       IgnoreDefaultInitialization(
           Options.get("IgnoreDefaultInitialization", true)) {}
 
 void MakeSmartPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
+  ClangTidyCheck::storeOptions(Opts);
   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,
   SourceLocation NewStart = NewRange.getBegin();
   SourceLocation NewEnd = NewRange.getEnd();
 
   // Skip when the source location of the new expression is invalid.
   if (NewStart.isInvalid() || NewEnd.isInvalid())
     return false;
 
   std::string ArraySizeExpr;
-  if (const auto* ArraySize = New->getArraySize().getValueOr(nullptr)) {
+  if (const auto *ArraySize = New->getArraySize().getValueOr(nullptr)) {
     ArraySizeExpr = Lexer::getSourceText(CharSourceRange::getTokenRange(
                                              ArraySize->getSourceRange()),
                                          SM, getLangOpts())
                         .str();
   }
   // Returns true if the given constructor expression has any braced-init-list
   // argument, e.g.
   //   Foo({1, 2}, 1) => true
if (const auto *CE = New->getConstructExpr()) {
       if (HasListIntializedArgument(CE))
         return false;
     }
     if (ArraySizeExpr.empty()) {
       SourceRange InitRange = New->getDirectInitRange();
       Diag << FixItHint::CreateRemoval(
           SourceRange(NewStart, InitRange.getBegin()));
       Diag << FixItHint::CreateRemoval(SourceRange(InitRange.getEnd(), NewEnd));
-    }
-    else {
+    } else {
       // New array expression with default/value initialization:
       //   smart_ptr<Foo[]>(new int[5]());
       //   smart_ptr<Foo[]>(new Foo[5]());
       Diag << FixItHint::CreateReplacement(SourceRange(NewStart, NewEnd),
                                            ArraySizeExpr);
     }
     break;
   }
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/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,
   unsigned ParamIdx = ParamDecl->getFunctionScopeIndex();
 
   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)),
+    : ClangTidyCheck(Name, Context, CheckFeatures::UseIncludeInserter),
       ValuesOnly(Options.get("ValuesOnly", false)) {}
 
 void PassByValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
+  ClangTidyCheck::storeOptions(Opts);
   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(
-              Result.SourceManager->getFileID(Initializer->getSourceLocation()),
-              "<utility>");
+       << createIncludeInsertion(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, CheckFeatures::UseIncludeInserter) {}
 
 void ReplaceAutoPtrCheck::registerMatchers(MatchFinder *Finder) {
   auto AutoPtrDecl = recordDecl(hasName("auto_ptr"), isInStdNamespace());
   auto AutoPtrType = qualType(hasDeclaration(AutoPtrDecl));
 
   //   std::auto_ptr<int> a;
   //        ^~~~~~~~~~~~~
   //
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;
     //        ^
if (AutoPtrLoc.isMacroID())
     AutoPtrLoc = SM.getSpellingLoc(AutoPtrLoc);
 
   // Ensure that only the 'auto_ptr' token is replaced and not the template
   // aliases.
   if (StringRef(SM.getCharacterData(AutoPtrLoc), strlen("auto_ptr")) !=
       "auto_ptr")
     return;
 
-  SourceLocation EndLoc =
-      AutoPtrLoc.getLocWithOffset(strlen("auto_ptr") - 1);
+  SourceLocation EndLoc = AutoPtrLoc.getLocWithOffset(strlen("auto_ptr") - 1);
   diag(AutoPtrLoc, "auto_ptr is deprecated, use unique_ptr instead")
       << FixItHint::CreateReplacement(SourceRange(AutoPtrLoc, EndLoc),
                                       "unique_ptr");
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

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, CheckFeatures::UseIncludeInserter) {}
 
 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(
-          MatchedCallExpr->getBeginLoc()),
-      "<random>");
+  Diag << createIncludeInsertion(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, CheckFeatures::UseIncludeInserter) {}
 
 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(
-        Result.Context->getSourceManager().getFileID(Call->getBeginLoc()),
-        "<cmath>");
+    Diag << createIncludeInsertion(Call->getBeginLoc(), "<cmath>");
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

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

 // to use a const reference.
 //
 // The check currently only understands a subset of variables that are
 // guaranteed to outlive the const reference returned, namely: const variables,
 // const references, and const pointers to const.
 class UnnecessaryCopyInitialization : public ClangTidyCheck {
 public:
   UnnecessaryCopyInitialization(StringRef Name, ClangTidyContext *Context);
-  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override{
+  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 storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   void handleCopyFromMethodReturn(const VarDecl &Var, const Stmt &BlockStmt,

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

if (Method->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization &&
       return true;
   return false;
 }
 
 } // namespace
 
 UnnecessaryValueParamCheck::UnnecessaryValueParamCheck(
     StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      Inserter(Options.getLocalOrGlobal("IncludeStyle",
-                                        utils::IncludeSorter::IS_LLVM)),
+    : ClangTidyCheck(Name, Context, CheckFeatures::UseIncludeInserter),
       AllowedTypes(
           utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
 
 void UnnecessaryValueParamCheck::registerMatchers(MatchFinder *Finder) {
   const auto ExpensiveValueParamDecl = parmVarDecl(
       hasType(qualType(
           hasCanonicalType(matchers::isExpensiveToCopy()),
           unless(anyOf(hasCanonicalType(referenceType()),
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());
+  ClangTidyCheck::storeOptions(Opts);
   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(CopyArgument.getBeginLoc(), "<utility>");
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

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

Style for formatting code around applied fixes:
   - '{ <json> }' specifies options inline, e.g.
     -format-style='{BasedOnStyle: llvm, IndentWidth: 8}'
   - 'llvm', 'google', 'webkit', 'mozilla'
 See clang-format documentation for the up-to-date
 information about formatting styles and options.
 This option overrides the 'FormatStyle` option in
 .clang-tidy file, if any.
 )"),
                                         cl::init("none"),
                                         cl::cat(ClangTidyCategory));
 
 static cl::opt<bool> ListChecks("list-checks", cl::desc(R"(
 List all enabled checks and exit. Use with
 -checks=* to list all available checks.
 )"),
                                 cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<bool> ExplainConfig("explain-config", cl::desc(R"(
)"),
                                         cl::cat(ClangTidyCategory));
 
 static cl::opt<bool> Quiet("quiet", cl::desc(R"(
 Run clang-tidy in quiet mode. This suppresses
 printing statistics about ignored warnings and
 warnings treated as errors if the respective
 options are specified.
 )"),
-                           cl::init(false),
-                           cl::cat(ClangTidyCategory));
+                           cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<std::string> VfsOverlay("vfsoverlay", cl::desc(R"(
 Overlay the virtual filesystem described by file
 over the real file system.
 )"),
                                        cl::value_desc("filename"),
                                        cl::cat(ClangTidyCategory));
 
if (Stats.errorsIgnored()) {
     llvm::errs() << ").\n";
     if (Stats.ErrorsIgnoredNonUserCode)
       llvm::errs() << "Use -header-filter=.* to display errors from all "
                       "non-system headers. Use -system-headers to display "
                       "errors from system headers as well.\n";
   }
 }
 
-static std::unique_ptr<ClangTidyOptionsProvider> createOptionsProvider(
-   llvm::IntrusiveRefCntPtr<vfs::FileSystem> FS) {
+static std::unique_ptr<ClangTidyOptionsProvider>
+createOptionsProvider(llvm::IntrusiveRefCntPtr<vfs::FileSystem> FS) {
   ClangTidyGlobalOptions GlobalOptions;
   if (std::error_code Err = parseLineFilter(LineFilter, GlobalOptions)) {
     llvm::errs() << "Invalid LineFilter: " << Err.message() << "\n\nUsage:\n";
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return nullptr;
   }
 
   ClangTidyOptions DefaultOptions;

clang-tools-extra/clang-tidy/utils/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 "FileExtensionsUtils.h"
+#include "../OptionEnumMapping.h"
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
+
 #include <string>
 
 namespace clang {
 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
enum IncludeKinds {
     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(const SourceManager *SourceMgr, const FileID FileID,
+  IncludeSorter(const SourceManager *SourceMgr, 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.

 } // 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/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`.
TransformerClangTidyCheck(std::function<Optional<transformer::RewriteRule>(
                                 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, CheckFeatures::UseIncludeInserter) {}
 
 // 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 &,
TransformerClangTidyCheck::TransformerClangTidyCheck(RewriteRule R,
   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(
-          Result.SourceManager->getFileID(T.Range.getBegin()), T.Replacement);
+      Diag << createIncludeInsertion(T.Range.getBegin(), T.Replacement);
       break;
     }
 }
 
-void TransformerClangTidyCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
-}
-
 } // namespace utils
 } // namespace tidy
 } // namespace clang