1 //===- unittest/Tooling/ToolingTest.cpp - Tooling unit tests --------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "clang/AST/ASTConsumer.h"
11 #include "clang/AST/DeclCXX.h"
12 #include "clang/AST/DeclGroup.h"
13 #include "clang/Frontend/ASTUnit.h"
14 #include "clang/Frontend/CompilerInstance.h"
15 #include "clang/Frontend/FrontendAction.h"
16 #include "clang/Frontend/FrontendActions.h"
17 #include "clang/Tooling/CompilationDatabase.h"
18 #include "clang/Tooling/Tooling.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/Config/llvm-config.h"
21 #include "llvm/Support/TargetSelect.h"
22 #include "llvm/Support/TargetRegistry.h"
23 #include "gtest/gtest.h"
24 #include <algorithm>
25 #include <string>
26
27 namespace clang {
28 namespace tooling {
29
30 namespace {
31 /// Takes an ast consumer and returns it from CreateASTConsumer. This only
32 /// works with single translation unit compilations.
33 class TestAction : public clang::ASTFrontendAction {
34 public:
35 /// Takes ownership of TestConsumer.
TestAction(std::unique_ptr<clang::ASTConsumer> TestConsumer)36 explicit TestAction(std::unique_ptr<clang::ASTConsumer> TestConsumer)
37 : TestConsumer(std::move(TestConsumer)) {}
38
39 protected:
40 std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance & compiler,StringRef dummy)41 CreateASTConsumer(clang::CompilerInstance &compiler,
42 StringRef dummy) override {
43 /// TestConsumer will be deleted by the framework calling us.
44 return std::move(TestConsumer);
45 }
46
47 private:
48 std::unique_ptr<clang::ASTConsumer> TestConsumer;
49 };
50
51 class FindTopLevelDeclConsumer : public clang::ASTConsumer {
52 public:
FindTopLevelDeclConsumer(bool * FoundTopLevelDecl)53 explicit FindTopLevelDeclConsumer(bool *FoundTopLevelDecl)
54 : FoundTopLevelDecl(FoundTopLevelDecl) {}
HandleTopLevelDecl(clang::DeclGroupRef DeclGroup)55 bool HandleTopLevelDecl(clang::DeclGroupRef DeclGroup) override {
56 *FoundTopLevelDecl = true;
57 return true;
58 }
59 private:
60 bool * const FoundTopLevelDecl;
61 };
62 } // end namespace
63
TEST(runToolOnCode,FindsNoTopLevelDeclOnEmptyCode)64 TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) {
65 bool FoundTopLevelDecl = false;
66 EXPECT_TRUE(
67 runToolOnCode(new TestAction(llvm::make_unique<FindTopLevelDeclConsumer>(
68 &FoundTopLevelDecl)),
69 ""));
70 EXPECT_FALSE(FoundTopLevelDecl);
71 }
72
73 namespace {
74 class FindClassDeclXConsumer : public clang::ASTConsumer {
75 public:
FindClassDeclXConsumer(bool * FoundClassDeclX)76 FindClassDeclXConsumer(bool *FoundClassDeclX)
77 : FoundClassDeclX(FoundClassDeclX) {}
HandleTopLevelDecl(clang::DeclGroupRef GroupRef)78 bool HandleTopLevelDecl(clang::DeclGroupRef GroupRef) override {
79 if (CXXRecordDecl* Record = dyn_cast<clang::CXXRecordDecl>(
80 *GroupRef.begin())) {
81 if (Record->getName() == "X") {
82 *FoundClassDeclX = true;
83 }
84 }
85 return true;
86 }
87 private:
88 bool *FoundClassDeclX;
89 };
FindClassDeclX(ASTUnit * AST)90 bool FindClassDeclX(ASTUnit *AST) {
91 for (std::vector<Decl *>::iterator i = AST->top_level_begin(),
92 e = AST->top_level_end();
93 i != e; ++i) {
94 if (CXXRecordDecl* Record = dyn_cast<clang::CXXRecordDecl>(*i)) {
95 if (Record->getName() == "X") {
96 return true;
97 }
98 }
99 }
100 return false;
101 }
102 } // end namespace
103
TEST(runToolOnCode,FindsClassDecl)104 TEST(runToolOnCode, FindsClassDecl) {
105 bool FoundClassDeclX = false;
106 EXPECT_TRUE(
107 runToolOnCode(new TestAction(llvm::make_unique<FindClassDeclXConsumer>(
108 &FoundClassDeclX)),
109 "class X;"));
110 EXPECT_TRUE(FoundClassDeclX);
111
112 FoundClassDeclX = false;
113 EXPECT_TRUE(
114 runToolOnCode(new TestAction(llvm::make_unique<FindClassDeclXConsumer>(
115 &FoundClassDeclX)),
116 "class Y;"));
117 EXPECT_FALSE(FoundClassDeclX);
118 }
119
TEST(buildASTFromCode,FindsClassDecl)120 TEST(buildASTFromCode, FindsClassDecl) {
121 std::unique_ptr<ASTUnit> AST = buildASTFromCode("class X;");
122 ASSERT_TRUE(AST.get());
123 EXPECT_TRUE(FindClassDeclX(AST.get()));
124
125 AST = buildASTFromCode("class Y;");
126 ASSERT_TRUE(AST.get());
127 EXPECT_FALSE(FindClassDeclX(AST.get()));
128 }
129
TEST(newFrontendActionFactory,CreatesFrontendActionFactoryFromType)130 TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) {
131 std::unique_ptr<FrontendActionFactory> Factory(
132 newFrontendActionFactory<SyntaxOnlyAction>());
133 std::unique_ptr<FrontendAction> Action(Factory->create());
134 EXPECT_TRUE(Action.get() != nullptr);
135 }
136
137 struct IndependentFrontendActionCreator {
newASTConsumerclang::tooling::IndependentFrontendActionCreator138 std::unique_ptr<ASTConsumer> newASTConsumer() {
139 return llvm::make_unique<FindTopLevelDeclConsumer>(nullptr);
140 }
141 };
142
TEST(newFrontendActionFactory,CreatesFrontendActionFactoryFromFactoryType)143 TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromFactoryType) {
144 IndependentFrontendActionCreator Creator;
145 std::unique_ptr<FrontendActionFactory> Factory(
146 newFrontendActionFactory(&Creator));
147 std::unique_ptr<FrontendAction> Action(Factory->create());
148 EXPECT_TRUE(Action.get() != nullptr);
149 }
150
TEST(ToolInvocation,TestMapVirtualFile)151 TEST(ToolInvocation, TestMapVirtualFile) {
152 llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem(
153 new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
154 llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
155 new vfs::InMemoryFileSystem);
156 OverlayFileSystem->pushOverlay(InMemoryFileSystem);
157 llvm::IntrusiveRefCntPtr<FileManager> Files(
158 new FileManager(FileSystemOptions(), OverlayFileSystem));
159 std::vector<std::string> Args;
160 Args.push_back("tool-executable");
161 Args.push_back("-Idef");
162 Args.push_back("-fsyntax-only");
163 Args.push_back("test.cpp");
164 clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction,
165 Files.get());
166 InMemoryFileSystem->addFile(
167 "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include <abc>\n"));
168 InMemoryFileSystem->addFile("def/abc", 0,
169 llvm::MemoryBuffer::getMemBuffer("\n"));
170 EXPECT_TRUE(Invocation.run());
171 }
172
TEST(ToolInvocation,TestVirtualModulesCompilation)173 TEST(ToolInvocation, TestVirtualModulesCompilation) {
174 // FIXME: Currently, this only tests that we don't exit with an error if a
175 // mapped module.map is found on the include path. In the future, expand this
176 // test to run a full modules enabled compilation, so we make sure we can
177 // rerun modules compilations with a virtual file system.
178 llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem(
179 new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
180 llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
181 new vfs::InMemoryFileSystem);
182 OverlayFileSystem->pushOverlay(InMemoryFileSystem);
183 llvm::IntrusiveRefCntPtr<FileManager> Files(
184 new FileManager(FileSystemOptions(), OverlayFileSystem));
185 std::vector<std::string> Args;
186 Args.push_back("tool-executable");
187 Args.push_back("-Idef");
188 Args.push_back("-fsyntax-only");
189 Args.push_back("test.cpp");
190 clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction,
191 Files.get());
192 InMemoryFileSystem->addFile(
193 "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include <abc>\n"));
194 InMemoryFileSystem->addFile("def/abc", 0,
195 llvm::MemoryBuffer::getMemBuffer("\n"));
196 // Add a module.map file in the include directory of our header, so we trigger
197 // the module.map header search logic.
198 InMemoryFileSystem->addFile("def/module.map", 0,
199 llvm::MemoryBuffer::getMemBuffer("\n"));
200 EXPECT_TRUE(Invocation.run());
201 }
202
203 struct VerifyEndCallback : public SourceFileCallbacks {
VerifyEndCallbackclang::tooling::VerifyEndCallback204 VerifyEndCallback() : BeginCalled(0), EndCalled(0), Matched(false) {}
handleBeginSourceclang::tooling::VerifyEndCallback205 bool handleBeginSource(CompilerInstance &CI, StringRef Filename) override {
206 ++BeginCalled;
207 return true;
208 }
handleEndSourceclang::tooling::VerifyEndCallback209 void handleEndSource() override { ++EndCalled; }
newASTConsumerclang::tooling::VerifyEndCallback210 std::unique_ptr<ASTConsumer> newASTConsumer() {
211 return llvm::make_unique<FindTopLevelDeclConsumer>(&Matched);
212 }
213 unsigned BeginCalled;
214 unsigned EndCalled;
215 bool Matched;
216 };
217
218 #if !defined(LLVM_ON_WIN32)
TEST(newFrontendActionFactory,InjectsSourceFileCallbacks)219 TEST(newFrontendActionFactory, InjectsSourceFileCallbacks) {
220 VerifyEndCallback EndCallback;
221
222 FixedCompilationDatabase Compilations("/", std::vector<std::string>());
223 std::vector<std::string> Sources;
224 Sources.push_back("/a.cc");
225 Sources.push_back("/b.cc");
226 ClangTool Tool(Compilations, Sources);
227
228 Tool.mapVirtualFile("/a.cc", "void a() {}");
229 Tool.mapVirtualFile("/b.cc", "void b() {}");
230
231 std::unique_ptr<FrontendActionFactory> Action(
232 newFrontendActionFactory(&EndCallback, &EndCallback));
233 Tool.run(Action.get());
234
235 EXPECT_TRUE(EndCallback.Matched);
236 EXPECT_EQ(2u, EndCallback.BeginCalled);
237 EXPECT_EQ(2u, EndCallback.EndCalled);
238 }
239 #endif
240
241 struct SkipBodyConsumer : public clang::ASTConsumer {
242 /// Skip the 'skipMe' function.
shouldSkipFunctionBodyclang::tooling::SkipBodyConsumer243 bool shouldSkipFunctionBody(Decl *D) override {
244 FunctionDecl *F = dyn_cast<FunctionDecl>(D);
245 return F && F->getNameAsString() == "skipMe";
246 }
247 };
248
249 struct SkipBodyAction : public clang::ASTFrontendAction {
CreateASTConsumerclang::tooling::SkipBodyAction250 std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
251 StringRef) override {
252 Compiler.getFrontendOpts().SkipFunctionBodies = true;
253 return llvm::make_unique<SkipBodyConsumer>();
254 }
255 };
256
TEST(runToolOnCode,TestSkipFunctionBody)257 TEST(runToolOnCode, TestSkipFunctionBody) {
258 EXPECT_TRUE(runToolOnCode(new SkipBodyAction,
259 "int skipMe() { an_error_here }"));
260 EXPECT_FALSE(runToolOnCode(new SkipBodyAction,
261 "int skipMeNot() { an_error_here }"));
262 }
263
TEST(runToolOnCodeWithArgs,TestNoDepFile)264 TEST(runToolOnCodeWithArgs, TestNoDepFile) {
265 llvm::SmallString<32> DepFilePath;
266 ASSERT_FALSE(
267 llvm::sys::fs::createTemporaryFile("depfile", "d", DepFilePath));
268 std::vector<std::string> Args;
269 Args.push_back("-MMD");
270 Args.push_back("-MT");
271 Args.push_back(DepFilePath.str());
272 Args.push_back("-MF");
273 Args.push_back(DepFilePath.str());
274 EXPECT_TRUE(runToolOnCodeWithArgs(new SkipBodyAction, "", Args));
275 EXPECT_FALSE(llvm::sys::fs::exists(DepFilePath.str()));
276 EXPECT_FALSE(llvm::sys::fs::remove(DepFilePath.str()));
277 }
278
TEST(ClangToolTest,ArgumentAdjusters)279 TEST(ClangToolTest, ArgumentAdjusters) {
280 FixedCompilationDatabase Compilations("/", std::vector<std::string>());
281
282 ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
283 Tool.mapVirtualFile("/a.cc", "void a() {}");
284
285 std::unique_ptr<FrontendActionFactory> Action(
286 newFrontendActionFactory<SyntaxOnlyAction>());
287
288 bool Found = false;
289 bool Ran = false;
290 ArgumentsAdjuster CheckSyntaxOnlyAdjuster =
291 [&Found, &Ran](const CommandLineArguments &Args, StringRef /*unused*/) {
292 Ran = true;
293 if (std::find(Args.begin(), Args.end(), "-fsyntax-only") != Args.end())
294 Found = true;
295 return Args;
296 };
297 Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster);
298 Tool.run(Action.get());
299 EXPECT_TRUE(Ran);
300 EXPECT_TRUE(Found);
301
302 Ran = Found = false;
303 Tool.clearArgumentsAdjusters();
304 Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster);
305 Tool.appendArgumentsAdjuster(getClangSyntaxOnlyAdjuster());
306 Tool.run(Action.get());
307 EXPECT_TRUE(Ran);
308 EXPECT_FALSE(Found);
309 }
310
311 namespace {
312 /// Find a target name such that looking for it in TargetRegistry by that name
313 /// returns the same target. We expect that there is at least one target
314 /// configured with this property.
getAnyTarget()315 std::string getAnyTarget() {
316 llvm::InitializeAllTargets();
317 for (const auto &Target : llvm::TargetRegistry::targets()) {
318 std::string Error;
319 StringRef TargetName(Target.getName());
320 if (TargetName == "x86-64")
321 TargetName = "x86_64";
322 if (llvm::TargetRegistry::lookupTarget(TargetName, Error) == &Target) {
323 return TargetName;
324 }
325 }
326 return "";
327 }
328 }
329
TEST(addTargetAndModeForProgramName,AddsTargetAndMode)330 TEST(addTargetAndModeForProgramName, AddsTargetAndMode) {
331 std::string Target = getAnyTarget();
332 ASSERT_FALSE(Target.empty());
333
334 std::vector<std::string> Args = {"clang", "-foo"};
335 addTargetAndModeForProgramName(Args, "");
336 EXPECT_EQ((std::vector<std::string>{"clang", "-foo"}), Args);
337 addTargetAndModeForProgramName(Args, Target + "-g++");
338 EXPECT_EQ((std::vector<std::string>{"clang", "-target", Target,
339 "--driver-mode=g++", "-foo"}),
340 Args);
341 }
342
TEST(addTargetAndModeForProgramName,PathIgnored)343 TEST(addTargetAndModeForProgramName, PathIgnored) {
344 std::string Target = getAnyTarget();
345 ASSERT_FALSE(Target.empty());
346
347 SmallString<32> ToolPath;
348 llvm::sys::path::append(ToolPath, "foo", "bar", Target + "-g++");
349
350 std::vector<std::string> Args = {"clang", "-foo"};
351 addTargetAndModeForProgramName(Args, ToolPath);
352 EXPECT_EQ((std::vector<std::string>{"clang", "-target", Target,
353 "--driver-mode=g++", "-foo"}),
354 Args);
355 }
356
TEST(addTargetAndModeForProgramName,IgnoresExistingTarget)357 TEST(addTargetAndModeForProgramName, IgnoresExistingTarget) {
358 std::string Target = getAnyTarget();
359 ASSERT_FALSE(Target.empty());
360
361 std::vector<std::string> Args = {"clang", "-foo", "-target", "something"};
362 addTargetAndModeForProgramName(Args, Target + "-g++");
363 EXPECT_EQ((std::vector<std::string>{"clang", "--driver-mode=g++", "-foo",
364 "-target", "something"}),
365 Args);
366
367 std::vector<std::string> ArgsAlt = {"clang", "-foo", "-target=something"};
368 addTargetAndModeForProgramName(ArgsAlt, Target + "-g++");
369 EXPECT_EQ((std::vector<std::string>{"clang", "--driver-mode=g++", "-foo",
370 "-target=something"}),
371 ArgsAlt);
372 }
373
TEST(addTargetAndModeForProgramName,IgnoresExistingMode)374 TEST(addTargetAndModeForProgramName, IgnoresExistingMode) {
375 std::string Target = getAnyTarget();
376 ASSERT_FALSE(Target.empty());
377
378 std::vector<std::string> Args = {"clang", "-foo", "--driver-mode=abc"};
379 addTargetAndModeForProgramName(Args, Target + "-g++");
380 EXPECT_EQ((std::vector<std::string>{"clang", "-target", Target, "-foo",
381 "--driver-mode=abc"}),
382 Args);
383
384 std::vector<std::string> ArgsAlt = {"clang", "-foo", "--driver-mode", "abc"};
385 addTargetAndModeForProgramName(ArgsAlt, Target + "-g++");
386 EXPECT_EQ((std::vector<std::string>{"clang", "-target", Target, "-foo",
387 "--driver-mode", "abc"}),
388 ArgsAlt);
389 }
390
391 #ifndef LLVM_ON_WIN32
TEST(ClangToolTest,BuildASTs)392 TEST(ClangToolTest, BuildASTs) {
393 FixedCompilationDatabase Compilations("/", std::vector<std::string>());
394
395 std::vector<std::string> Sources;
396 Sources.push_back("/a.cc");
397 Sources.push_back("/b.cc");
398 ClangTool Tool(Compilations, Sources);
399
400 Tool.mapVirtualFile("/a.cc", "void a() {}");
401 Tool.mapVirtualFile("/b.cc", "void b() {}");
402
403 std::vector<std::unique_ptr<ASTUnit>> ASTs;
404 EXPECT_EQ(0, Tool.buildASTs(ASTs));
405 EXPECT_EQ(2u, ASTs.size());
406 }
407
408 struct TestDiagnosticConsumer : public DiagnosticConsumer {
TestDiagnosticConsumerclang::tooling::TestDiagnosticConsumer409 TestDiagnosticConsumer() : NumDiagnosticsSeen(0) {}
HandleDiagnosticclang::tooling::TestDiagnosticConsumer410 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
411 const Diagnostic &Info) override {
412 ++NumDiagnosticsSeen;
413 }
414 unsigned NumDiagnosticsSeen;
415 };
416
TEST(ClangToolTest,InjectDiagnosticConsumer)417 TEST(ClangToolTest, InjectDiagnosticConsumer) {
418 FixedCompilationDatabase Compilations("/", std::vector<std::string>());
419 ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
420 Tool.mapVirtualFile("/a.cc", "int x = undeclared;");
421 TestDiagnosticConsumer Consumer;
422 Tool.setDiagnosticConsumer(&Consumer);
423 std::unique_ptr<FrontendActionFactory> Action(
424 newFrontendActionFactory<SyntaxOnlyAction>());
425 Tool.run(Action.get());
426 EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
427 }
428
TEST(ClangToolTest,InjectDiagnosticConsumerInBuildASTs)429 TEST(ClangToolTest, InjectDiagnosticConsumerInBuildASTs) {
430 FixedCompilationDatabase Compilations("/", std::vector<std::string>());
431 ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
432 Tool.mapVirtualFile("/a.cc", "int x = undeclared;");
433 TestDiagnosticConsumer Consumer;
434 Tool.setDiagnosticConsumer(&Consumer);
435 std::vector<std::unique_ptr<ASTUnit>> ASTs;
436 Tool.buildASTs(ASTs);
437 EXPECT_EQ(1u, ASTs.size());
438 EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
439 }
440 #endif
441
442 } // end namespace tooling
443 } // end namespace clang
444