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.value(); 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 114