clang/unittests/Tooling/RefactoringCallbacksTest.cpp

   1 //===- unittest/Tooling/RefactoringCallbacksTest.cpp ----------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "RewriterTestContext.h"
  10 #include "clang/ASTMatchers/ASTMatchFinder.h"
  11 #include "clang/ASTMatchers/ASTMatchers.h"
  12 #include "clang/Tooling/RefactoringCallbacks.h"
  13 #include "gtest/gtest.h"
  14
  15 namespace clang {
  16 namespace tooling {
  17
  18 using namespace ast_matchers;
  19
  20 template <typename T>
  21 void expectRewritten(const std::string &Code, const std::string &Expected,
  22                      const T &AMatcher, RefactoringCallback &Callback) {
  23   std::map<std::string, Replacements> FileToReplace;
  24   ASTMatchRefactorer Finder(FileToReplace);
  25   Finder.addMatcher(traverse(TK_AsIs, AMatcher), &Callback);
  26   std::unique_ptr<tooling::FrontendActionFactory> Factory(
  27       tooling::newFrontendActionFactory(&Finder));
  28   ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), Code))
  29       << "Parsing error in \"" << Code << "\"";
  30   RewriterTestContext Context;
  31   FileID ID = Context.createInMemoryFile("input.cc", Code);
  32   EXPECT_TRUE(tooling::applyAllReplacements(FileToReplace["input.cc"],
  33                                             Context.Rewrite));
  34   EXPECT_EQ(Expected, Context.getRewrittenText(ID));
  35 }
  36
  37 TEST(RefactoringCallbacksTest, ReplacesStmtsWithString) {
  38   std::string Code = "void f() { int i = 1; }";
  39   std::string Expected = "void f() { ; }";
  40   ReplaceStmtWithText Callback("id", ";");
  41   expectRewritten(Code, Expected, declStmt().bind("id"), Callback);
  42 }
  43
  44 TEST(RefactoringCallbacksTest, ReplacesStmtsInCalledMacros) {
  45   std::string Code = "#define A void f() { int i = 1; }\nA";
  46   std::string Expected = "#define A void f() { ; }\nA";
  47   ReplaceStmtWithText Callback("id", ";");
  48   expectRewritten(Code, Expected, declStmt().bind("id"), Callback);
  49 }
  50
  51 TEST(RefactoringCallbacksTest, IgnoresStmtsInUncalledMacros) {
  52   std::string Code = "#define A void f() { int i = 1; }";
  53   std::string Expected = "#define A void f() { int i = 1; }";
  54   ReplaceStmtWithText Callback("id", ";");
  55   expectRewritten(Code, Expected, declStmt().bind("id"), Callback);
  56 }
  57
  58 TEST(RefactoringCallbacksTest, ReplacesInteger) {
  59   std::string Code = "void f() { int i = 1; }";
  60   std::string Expected = "void f() { int i = 2; }";
  61   ReplaceStmtWithText Callback("id", "2");
  62   expectRewritten(Code, Expected, expr(integerLiteral()).bind("id"), Callback);
  63 }
  64
  65 TEST(RefactoringCallbacksTest, ReplacesStmtWithStmt) {
  66   std::string Code = "void f() { int i = false ? 1 : i * 2; }";
  67   std::string Expected = "void f() { int i = i * 2; }";
  68   ReplaceStmtWithStmt Callback("always-false", "should-be");
  69   expectRewritten(
  70       Code, Expected,
  71       conditionalOperator(hasCondition(cxxBoolLiteral(equals(false))),
  72                           hasFalseExpression(expr().bind("should-be")))
  73           .bind("always-false"),
  74       Callback);
  75 }
  76
  77 TEST(RefactoringCallbacksTest, ReplacesIfStmt) {
  78   std::string Code = "bool a; void f() { if (a) f(); else a = true; }";
  79   std::string Expected = "bool a; void f() { f(); }";
  80   ReplaceIfStmtWithItsBody Callback("id", true);
  81   expectRewritten(Code, Expected,
  82                   ifStmt(hasCondition(implicitCastExpr(hasSourceExpression(
  83                              declRefExpr(to(varDecl(hasName("a"))))))))
  84                       .bind("id"),
  85                   Callback);
  86 }
  87
  88 TEST(RefactoringCallbacksTest, RemovesEntireIfOnEmptyElse) {
  89   std::string Code = "void f() { if (false) int i = 0; }";
  90   std::string Expected = "void f() {  }";
  91   ReplaceIfStmtWithItsBody Callback("id", false);
  92   expectRewritten(
  93       Code, Expected,
  94       ifStmt(hasCondition(cxxBoolLiteral(equals(false)))).bind("id"), Callback);
  95 }
  96
  97 TEST(RefactoringCallbacksTest, TemplateJustText) {
  98   std::string Code = "void f() { int i = 1; }";
  99   std::string Expected = "void f() { FOO }";
 100   auto Callback = ReplaceNodeWithTemplate::create("id", "FOO");
 101   EXPECT_FALSE(Callback.takeError());
 102   expectRewritten(Code, Expected, declStmt().bind("id"), **Callback);
 103 }
 104
 105 TEST(RefactoringCallbacksTest, TemplateSimpleSubst) {
 106   std::string Code = "void f() { int i = 1; }";
 107   std::string Expected = "void f() { long x = 1; }";
 108   auto Callback = ReplaceNodeWithTemplate::create("decl", "long x = ${init}");
 109   EXPECT_FALSE(Callback.takeError());
 110   expectRewritten(Code, Expected,
 111                   varDecl(hasInitializer(expr().bind("init"))).bind("decl"),
 112                   **Callback);
 113 }
 114
 115 TEST(RefactoringCallbacksTest, TemplateLiteral) {
 116   std::string Code = "void f() { int i = 1; }";
 117   std::string Expected = "void f() { string x = \"$-1\"; }";
 118   auto Callback = ReplaceNodeWithTemplate::create("decl",
 119                                                   "string x = \"$$-${init}\"");
 120   EXPECT_FALSE(Callback.takeError());
 121   expectRewritten(Code, Expected,
 122                   varDecl(hasInitializer(expr().bind("init"))).bind("decl"),
 123                   **Callback);
 124 }
 125
 126 static void ExpectStringError(const std::string &Expected,
 127                               llvm::Error E) {
 128   std::string Found;
 129   handleAllErrors(std::move(E), [&](const llvm::StringError &SE) {
 130       llvm::raw_string_ostream Stream(Found);
 131       SE.log(Stream);
 132     });
 133   EXPECT_EQ(Expected, Found);
 134 }
 135
 136 TEST(RefactoringCallbacksTest, TemplateUnterminated) {
 137   auto Callback = ReplaceNodeWithTemplate::create("decl",
 138                                                   "string x = \"$$-${init\"");
 139   ExpectStringError("Unterminated ${...} in replacement template near ${init\"",
 140                     Callback.takeError());
 141 }
 142
 143 TEST(RefactoringCallbacksTest, TemplateUnknownDollar) {
 144   auto Callback = ReplaceNodeWithTemplate::create("decl",
 145                                                   "string x = \"$<");
 146   ExpectStringError("Invalid $ in replacement template near $<",
 147                     Callback.takeError());
 148 }
 149
 150 } // namespace tooling
 151 } // end namespace clang