[clang-tidy] Update TransformerClangTidyCheck to use new Transformer bindings.

[ymandel]

Summary

Updates the relevant source files to use bindings in clang::transformer rather
than clang::tooling.

[ilya-biryukov]

LGTM

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

public:
   //
   // All cases in the rule generated by \p MakeRule 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).
-  TransformerClangTidyCheck(std::function<Optional<tooling::RewriteRule>(
+  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 depend on any
   // of the language or clang-tidy options.
-  TransformerClangTidyCheck(tooling::RewriteRule R, StringRef Name,
+  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;
 
 private:
-  Optional<tooling::RewriteRule> Rule;
+  Optional<transformer::RewriteRule> Rule;
   std::unique_ptr<clang::tidy::utils::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

 //===---------- TransformerClangTidyCheck.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 "TransformerClangTidyCheck.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
-using tooling::RewriteRule;
+using transformer::RewriteRule;
 
 #ifndef NDEBUG
 static bool hasExplanation(const RewriteRule::Case &C) {
   return C.Explanation != nullptr;
 }
 #endif
 
 // This constructor cannot dispatch to the simpler one (below), because, in
Inserter = std::make_unique<IncludeInserter>(
         SM, getLangOpts(), utils::IncludeSorter::IS_LLVM);
     PP->addPPCallbacks(Inserter->CreatePPCallbacks());
   }
 }
 
 void TransformerClangTidyCheck::registerMatchers(
     ast_matchers::MatchFinder *Finder) {
   if (Rule)
-    for (auto &Matcher : tooling::detail::buildMatchers(*Rule))
+    for (auto &Matcher : transformer::detail::buildMatchers(*Rule))
       Finder->addDynamicMatcher(Matcher, this);
 }
 
 void TransformerClangTidyCheck::check(
     const ast_matchers::MatchFinder::MatchResult &Result) {
   if (Result.Context->getDiagnostics().hasErrorOccurred())
     return;
 
   assert(Rule && "check() should not fire if Rule is None");
-  RewriteRule::Case Case = tooling::detail::findSelectedCase(Result, *Rule);
-  Expected<SmallVector<tooling::detail::Transformation, 1>> Transformations =
-      tooling::detail::translateEdits(Result, Case.Edits);
+  RewriteRule::Case Case = transformer::detail::findSelectedCase(Result, *Rule);
+  Expected<SmallVector<transformer::detail::Transformation, 1>>
+      Transformations = transformer::detail::translateEdits(Result, Case.Edits);
   if (!Transformations) {
     llvm::errs() << "Rewrite failed: "
                  << llvm::toString(Transformations.takeError()) << "\n";
     return;
   }
 
   // No rewrite applied, but no error encountered either.
   if (Transformations->empty())
DiagnosticBuilder Diag =
       diag((*Transformations)[0].Range.getBegin(), *Explanation);
   for (const auto &T : *Transformations)
     Diag << FixItHint::CreateReplacement(T.Range, T.Replacement);
 
   for (const auto &I : Case.AddedIncludes) {
     auto &Header = I.first;
     if (Optional<FixItHint> Fix = Inserter->CreateIncludeInsertion(
             Result.SourceManager->getMainFileID(), Header,
-            /*IsAngled=*/I.second == tooling::IncludeFormat::Angled)) {
+            /*IsAngled=*/I.second == transformer::IncludeFormat::Angled)) {
       Diag << *Fix;
     }
   }
 }
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang

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

 #include "gtest/gtest.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 namespace {
 using namespace ::clang::ast_matchers;
 
-using tooling::change;
-using tooling::IncludeFormat;
-using tooling::node;
-using tooling::RewriteRule;
-using tooling::statement;
-using tooling::text;
-using tooling::stencil::cat;
+using transformer::cat;
+using transformer::change;
+using transformer::IncludeFormat;
+using transformer::node;
+using transformer::RewriteRule;
+using transformer::statement;
 
 // Invert the code of an if-statement, while maintaining its semantics.
 RewriteRule invertIf() {
   StringRef C = "C", T = "T", E = "E";
   RewriteRule Rule = tooling::makeRule(
       ifStmt(hasCondition(expr().bind(C)), hasThen(stmt().bind(T)),
              hasElse(stmt().bind(E))),
       change(
           statement(RewriteRule::RootID),
           cat("if(!(", node(C), ")) ", statement(E), " else ", statement(T))),
-      text("negate condition and reverse `then` and `else` branches"));
+      cat("negate condition and reverse `then` and `else` branches"));
   return Rule;
 }
 
 class IfInverterCheck : public TransformerClangTidyCheck {
 public:
   IfInverterCheck(StringRef Name, ClangTidyContext *Context)
       : TransformerClangTidyCheck(invertIf(), Name, Context) {}
 };
TEST(TransformerClangTidyCheckTest, Basic) {
   )";
   EXPECT_EQ(Expected, test::runCheckOnCode<IfInverterCheck>(Input));
 }
 
 class IntLitCheck : public TransformerClangTidyCheck {
 public:
   IntLitCheck(StringRef Name, ClangTidyContext *Context)
       : TransformerClangTidyCheck(tooling::makeRule(integerLiteral(),
-                                                    change(text("LIT")),
-                                                    text("no message")),
+                                                    change(cat("LIT")),
+                                                    cat("no message")),
                                   Name, Context) {}
 };
 
 // Tests that two changes in a single macro expansion do not lead to conflicts
 // in applying the changes.
 TEST(TransformerClangTidyCheckTest, TwoChangesInOneMacroExpansion) {
   const std::string Input = R"cc(
 #define PLUS(a,b) (a) + (b)
     int f() { return PLUS(3, 4); }
   )cc";
   const std::string Expected = R"cc(
 #define PLUS(a,b) (a) + (b)
     int f() { return PLUS(LIT, LIT); }
   )cc";
 
   EXPECT_EQ(Expected, test::runCheckOnCode<IntLitCheck>(Input));
 }
 
 class BinOpCheck : public TransformerClangTidyCheck {
 public:
   BinOpCheck(StringRef Name, ClangTidyContext *Context)
       : TransformerClangTidyCheck(
             tooling::makeRule(
                 binaryOperator(hasOperatorName("+"), hasRHS(expr().bind("r"))),
-                change(node("r"), text("RIGHT")), text("no message")),
+                change(node("r"), cat("RIGHT")), cat("no message")),
             Name, Context) {}
 };
 
 // Tests case where the rule's match spans both source from the macro and its
 // argument, while the change spans only the argument AND there are two such
 // matches. We verify that both replacements succeed.
 TEST(TransformerClangTidyCheckTest, TwoMatchesInMacroExpansion) {
   const std::string Input = R"cc(

 }
 
 // A trivial rewrite-rule generator that requires Objective-C code.
 Optional<RewriteRule> needsObjC(const LangOptions &LangOpts,
                                 const ClangTidyCheck::OptionsView &Options) {
   if (!LangOpts.ObjC)
     return None;
   return tooling::makeRule(clang::ast_matchers::functionDecl(),
-                           change(cat("void changed() {}")), text("no message"));
+                           change(cat("void changed() {}")), cat("no message"));
 }
 
 class NeedsObjCCheck : public TransformerClangTidyCheck {
 public:
   NeedsObjCCheck(StringRef Name, ClangTidyContext *Context)
       : TransformerClangTidyCheck(needsObjC, Name, Context) {}
 };
 
 // Verify that the check only rewrites the code when the input is Objective-C.
 TEST(TransformerClangTidyCheckTest, DisableByLang) {
   const std::string Input = "void log() {}";
   EXPECT_EQ(Input,
             test::runCheckOnCode<NeedsObjCCheck>(Input, nullptr, "input.cc"));
 
   EXPECT_EQ("void changed() {}",
             test::runCheckOnCode<NeedsObjCCheck>(Input, nullptr, "input.mm"));
 }
 
 // A trivial rewrite rule generator that checks config options.
 Optional<RewriteRule> noSkip(const LangOptions &LangOpts,
                              const ClangTidyCheck::OptionsView &Options) {
   if (Options.get("Skip", "false") == "true")
     return None;
   return tooling::makeRule(clang::ast_matchers::functionDecl(),
-                           change(cat("void nothing()")), text("no message"));
+                           change(cat("void nothing()")), cat("no message"));
 }
 
 class ConfigurableCheck : public TransformerClangTidyCheck {
 public:
   ConfigurableCheck(StringRef Name, ClangTidyContext *Context)
       : TransformerClangTidyCheck(noSkip, Name, Context) {}
 };
 
TEST(TransformerClangTidyCheckTest, DisableByConfig) {
   EXPECT_EQ(Expected, test::runCheckOnCode<ConfigurableCheck>(
                           Input, nullptr, "input.cc", None, Options));
 }
 
 RewriteRule replaceCall(IncludeFormat Format) {
   using namespace ::clang::ast_matchers;
   RewriteRule Rule =
       tooling::makeRule(callExpr(callee(functionDecl(hasName("f")))),
-                        change(text("other()")), text("no message"));
+                        change(cat("other()")), cat("no message"));
   addInclude(Rule, "clang/OtherLib.h", Format);
   return Rule;
 }
 
 template <IncludeFormat Format>
 class IncludeCheck : public TransformerClangTidyCheck {
 public:
   IncludeCheck(StringRef Name, ClangTidyContext *Context)