[libTooling][NFC] Remove deprecated Clang Transformer declarations

[ymandel]

Summary

A number of declarations were leftover after the move from clang::tooling to
clang::transformer. This patch removes those declarations and upgrades the
handful of references to the deprecated declarations.

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

 namespace tidy {
 namespace abseil {
 
 using ::clang::transformer::applyFirst;
 using ::clang::transformer::cat;
 using ::clang::transformer::change;
 using ::clang::transformer::makeRule;
 using ::clang::transformer::node;
+using ::clang::transformer::RewriteRule;
 
 static const char DefaultStringLikeClasses[] = "::std::basic_string;"
                                                "::std::basic_string_view;"
                                                "::absl::string_view";
 static const char DefaultAbseilStringsMatchHeader[] = "absl/strings/match.h";
 
 static llvm::Optional<transformer::RewriteRule>
 MakeRule(const LangOptions &LangOpts,
auto StringFind = cxxMemberCallExpr(
           hasName("find"),
           hasParameter(0, parmVarDecl(anyOf(hasType(StringType),
                                             hasType(CharStarType)))))),
       on(hasType(StringType)), hasArgument(0, expr().bind("parameter_to_find")),
       anyOf(hasArgument(1, integerLiteral(equals(0))),
             hasArgument(1, cxxDefaultArgExpr())),
       onImplicitObjectArgument(expr().bind("string_being_searched")));
 
-  tooling::RewriteRule rule = applyFirst(
+  RewriteRule rule = applyFirst(
       {makeRule(binaryOperator(hasOperatorName("=="),
                                hasOperands(ignoringParenImpCasts(StringNpos),
                                            ignoringParenImpCasts(StringFind))),
                 change(cat("!absl::StrContains(", node("string_being_searched"),
                            ", ", node("parameter_to_find"), ")")),
                 cat("use !absl::StrContains instead of find() == npos")),
        makeRule(binaryOperator(hasOperatorName("!="),
                                hasOperands(ignoringParenImpCasts(StringNpos),

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

 namespace tidy {
 namespace utils {
 namespace {
 using namespace ::clang::ast_matchers;
 
 using transformer::cat;
 using transformer::change;
 using transformer::IncludeFormat;
+using transformer::makeRule;
 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)),
+  RewriteRule Rule =
+      makeRule(ifStmt(hasCondition(expr().bind(C)), hasThen(stmt().bind(T)),
                       hasElse(stmt().bind(E))),
                change(statement(std::string(RewriteRule::RootID)),
                       cat("if(!(", node(std::string(C)), ")) ",
                           statement(std::string(E)), " else ",
                           statement(std::string(T)))),
                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) {}
 };
const std::string Expected = R"(
     }
   )";
   EXPECT_EQ(Expected, test::runCheckOnCode<IfInverterCheck>(Input));
 }
 
 class IntLitCheck : public TransformerClangTidyCheck {
 public:
   IntLitCheck(StringRef Name, ClangTidyContext *Context)
-      : TransformerClangTidyCheck(tooling::makeRule(integerLiteral(),
-                                                    change(cat("LIT")),
-                                                    cat("no message")),
-                                  Name, Context) {}
+      : TransformerClangTidyCheck(
+            makeRule(integerLiteral(), change(cat("LIT")), cat("no message")),
 };
 
 // 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(
+            makeRule(
                 binaryOperator(hasOperatorName("+"), hasRHS(expr().bind("r"))),
                 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.
#define M(a,b) (1 + a) * (1 + b)
   EXPECT_EQ(Expected, test::runCheckOnCode<BinOpCheck>(Input));
 }
 
 // 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() {}")), cat("no message"));
+  return makeRule(clang::ast_matchers::functionDecl(),
 }
 
 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(),
-                           changeTo(cat("void nothing();")), cat("no message"));
+  return makeRule(clang::ast_matchers::functionDecl(),
 }
 
 class ConfigurableCheck : public TransformerClangTidyCheck {
 public:
   ConfigurableCheck(StringRef Name, ClangTidyContext *Context)
       : TransformerClangTidyCheck(noSkip, Name, Context) {}
 };
 
TEST(TransformerClangTidyCheckTest, DisableByConfig) {
 
   Options.CheckOptions["test-check-0.Skip"] = "false";
   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")))),
+  RewriteRule Rule = makeRule(callExpr(callee(functionDecl(hasName("f")))),
                               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)

clang/include/clang/Tooling/Transformer/RangeSelector.h

 /// starting from the \c else keyword.
 RangeSelector elseBranch(std::string ID);
 
 /// Selects the range from which `S` was expanded (possibly along with other
 /// source), if `S` is an expansion, and `S` itself, otherwise.  Corresponds to
 /// `SourceManager::getExpansionRange`.
 RangeSelector expansion(RangeSelector S);
 } // namespace transformer
-
-namespace tooling {
-// DEPRECATED: These are temporary aliases supporting client migration to the
-// `transformer` namespace.
-using RangeSelector = transformer::RangeSelector;
-
-using transformer::after;
-using transformer::before;
-using transformer::callArgs;
-using transformer::charRange;
-using transformer::elseBranch;
-using transformer::expansion;
-using transformer::initListElements;
-using transformer::member;
-using transformer::name;
-using transformer::node;
-using transformer::range;
-using transformer::statement;
-using transformer::statements;
-} // namespace tooling
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLING_REFACTOR_RANGE_SELECTOR_H_

clang/include/clang/Tooling/Transformer/RewriteRule.h

 
 /// Returns the \c Case of \c Rule that was selected in the match result.
 /// Assumes a matcher built with \c buildMatcher.
 const RewriteRule::Case &
 findSelectedCase(const ast_matchers::MatchFinder::MatchResult &Result,
                  const RewriteRule &Rule);
 } // namespace detail
 } // namespace transformer
-
-namespace tooling {
-// DEPRECATED: These are temporary aliases supporting client migration to the
-// `transformer` namespace.
-/// Wraps a string as a TextGenerator.
-using TextGenerator = transformer::TextGenerator;
-
-TextGenerator text(std::string M);
-
-using transformer::addInclude;
-using transformer::applyFirst;
-using transformer::change;
-using transformer::insertAfter;
-using transformer::insertBefore;
-using transformer::makeRule;
-using transformer::remove;
-using transformer::RewriteRule;
-using transformer::IncludeFormat;
-namespace detail {
-using namespace transformer::detail;
-} // namespace detail
-} // namespace tooling
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLING_TRANSFORMER_REWRITE_RULE_H_

clang/lib/Tooling/Transformer/RewriteRule.cpp

for (size_t i = 0, N = Rule.Cases.size(); i < N; ++i) {
     std::string Tag = ("Tag" + Twine(i)).str();
     if (NodesMap.find(Tag) != NodesMap.end())
       return Rule.Cases[i];
   }
   llvm_unreachable("No tag found for this rule.");
 }
 
 const llvm::StringRef RewriteRule::RootID = ::clang::transformer::RootID;
-
-TextGenerator tooling::text(std::string M) {
-  return std::make_shared<SimpleTextGenerator>(std::move(M));
-}

clang/unittests/Tooling/TransformerTest.cpp

 #include "llvm/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace tooling;
 using namespace ast_matchers;
 namespace {
+using ::clang::transformer::addInclude;
+using ::clang::transformer::applyFirst;
+using ::clang::transformer::before;
+using ::clang::transformer::cat;
+using ::clang::transformer::changeTo;
+using ::clang::transformer::makeRule;
+using ::clang::transformer::member;
+using ::clang::transformer::name;
+using ::clang::transformer::node;
+using ::clang::transformer::remove;
+using ::clang::transformer::rewriteDescendants;
+using ::clang::transformer::RewriteRule;
+using ::clang::transformer::statement;
 using ::testing::ElementsAre;
 using ::testing::IsEmpty;
-using transformer::cat;
-using transformer::changeTo;
-using transformer::rewriteDescendants;
-using transformer::RewriteRule;
 
 constexpr char KHeaderContents[] = R"cc(
   struct string {
     string(const char*);
     char* c_str();
     int size();
   };
   int strlen(const char*);
Transformer T(makeRule(declRefExpr(to(functionDecl())).bind(Ref),
                          changeTo(name(std::string(Ref)), cat("good"))),
                 consumer());
   T.registerMatchers(&MatchFinder);
   EXPECT_FALSE(rewrite(Input));
 }
 
 TEST_F(TransformerTest, NodePartMember) {
   StringRef E = "expr";
-  RewriteRule Rule = makeRule(memberExpr(member(hasName("bad"))).bind(E),
-                              changeTo(member(std::string(E)), cat("good")));
+  RewriteRule Rule =
+      makeRule(memberExpr(clang::ast_matchers::member(hasName("bad"))).bind(E),
 
   std::string Input = R"cc(
     struct S {
       int bad;
     };
     int g() {
       S s;
       return s.bad;