| 1 |
//===---- UsingInserterTest.cpp - clang-tidy ----------------------------===// |
| 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 "../clang-tidy/utils/UsingInserter.h" |
| 10 |
|
| 11 |
#include "ClangTidyTest.h" |
| 12 |
#include "clang/ASTMatchers/ASTMatchFinder.h" |
| 13 |
#include "clang/ASTMatchers/ASTMatchers.h" |
| 14 |
#include "gtest/gtest.h" |
| 15 |
|
| 16 |
namespace clang { |
| 17 |
namespace tidy { |
| 18 |
namespace utils { |
| 19 |
|
| 20 |
// Replace all function calls with calls to foo::func. Inserts using |
| 21 |
// declarations as necessary. This checker is for testing only. It |
| 22 |
// can only run on one test case (e.g. wih one SourceManager). |
| 23 |
class InsertUsingCheck : public clang::tidy::ClangTidyCheck { |
| 24 |
public: |
| 25 |
InsertUsingCheck(StringRef Name, ClangTidyContext *Context) |
| 26 |
:ClangTidyCheck(Name, Context) {} |
| 27 |
void registerMatchers(clang::ast_matchers::MatchFinder *Finder) override { |
| 28 |
Finder->addMatcher(clang::ast_matchers::callExpr().bind("foo"), this); |
| 29 |
} |
| 30 |
void |
| 31 |
check(const clang::ast_matchers::MatchFinder::MatchResult &Result) override { |
| 32 |
if (!Inserter) |
| 33 |
Inserter.reset(new UsingInserter(*Result.SourceManager)); |
| 34 |
|
| 35 |
const auto *Call = Result.Nodes.getNodeAs<clang::CallExpr>("foo"); |
| 36 |
assert(Call != nullptr && "Did not find node \"foo\""); |
| 37 |
auto Hint = |
| 38 |
Inserter->createUsingDeclaration(*Result.Context, *Call, "::foo::func"); |
| 39 |
|
| 40 |
if (Hint) |
| 41 |
diag(Call->getBeginLoc(), "Fix for testing") << *Hint; |
| 42 |
|
| 43 |
diag(Call->getBeginLoc(), "insert call") |
| 44 |
<< clang::FixItHint::CreateReplacement( |
| 45 |
Call->getCallee()->getSourceRange(), |
| 46 |
Inserter->getShortName(*Result.Context, *Call, "::foo::func")); |
| 47 |
} |
| 48 |
|
| 49 |
private: |
| 50 |
std::unique_ptr<UsingInserter> Inserter; |
| 51 |
}; |
| 52 |
|
| 53 |
template <typename Check> |
| 54 |
std::string runChecker(StringRef Code, unsigned ExpectedWarningCount) { |
| 55 |
std::map<StringRef, StringRef> AdditionalFileContents = {{"foo.h", |
| 56 |
"namespace foo {\n" |
| 57 |
"namespace bar {\n" |
| 58 |
"}\n" |
| 59 |
"void func() { }\n" |
| 60 |
"}"}}; |
| 61 |
std::vector<ClangTidyError> errors; |
| 62 |
|
| 63 |
std::string result = |
| 64 |
test::runCheckOnCode<Check>(Code, &errors, "foo.cc", std::nullopt, |
| 65 |
ClangTidyOptions(), AdditionalFileContents); |
| 66 |
|
| 67 |
EXPECT_EQ(ExpectedWarningCount, errors.size()); |
| 68 |
return result; |
| 69 |
} |
| 70 |
|
| 71 |
TEST(UsingInserterTest, ReusesExisting) { |
| 72 |
EXPECT_EQ("#include \"foo.h\"\n" |
| 73 |
"namespace {" |
| 74 |
"using ::foo::func;\n" |
| 75 |
"void f() { func(); }" |
| 76 |
"}", |
| 77 |
runChecker<InsertUsingCheck>("#include \"foo.h\"\n" |
| 78 |
"namespace {" |
| 79 |
"using ::foo::func;\n" |
| 80 |
"void f() { f(); }" |
| 81 |
"}", |
| 82 |
1)); |
| 83 |
} |
| 84 |
|
| 85 |
TEST(UsingInserterTest, ReusesExistingGlobal) { |
| 86 |
EXPECT_EQ("#include \"foo.h\"\n" |
| 87 |
"using ::foo::func;\n" |
| 88 |
"namespace {" |
| 89 |
"void f() { func(); }" |
| 90 |
"}", |
| 91 |
runChecker<InsertUsingCheck>("#include \"foo.h\"\n" |
| 92 |
"using ::foo::func;\n" |
| 93 |
"namespace {" |
| 94 |
"void f() { f(); }" |
| 95 |
"}", |
| 96 |
1)); |
| 97 |
} |
| 98 |
|
| 99 |
TEST(UsingInserterTest, AvoidsConflict) { |
| 100 |
EXPECT_EQ("#include \"foo.h\"\n" |
| 101 |
"namespace {" |
| 102 |
"void f() { int func; ::foo::func(); }" |
| 103 |
"}", |
| 104 |
runChecker<InsertUsingCheck>("#include \"foo.h\"\n" |
| 105 |
"namespace {" |
| 106 |
"void f() { int func; f(); }" |
| 107 |
"}", |
| 108 |
1)); |
| 109 |
} |
| 110 |
|
| 111 |
} // namespace utils |
| 112 |
} // namespace tidy |
| 113 |
} // namespace clang |