| 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 |