1 //===- unittest/Tooling/ToolingTest.cpp - Tooling unit tests --------------===//
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/Tooling/Tooling.h"
10 #include "clang/AST/ASTConsumer.h"
11 #include "clang/AST/DeclCXX.h"
12 #include "clang/AST/DeclGroup.h"
13 #include "clang/Driver/Compilation.h"
14 #include "clang/Driver/Driver.h"
15 #include "clang/Frontend/ASTUnit.h"
16 #include "clang/Frontend/CompilerInstance.h"
17 #include "clang/Frontend/FrontendAction.h"
18 #include "clang/Frontend/FrontendActions.h"
19 #include "clang/Frontend/TextDiagnosticBuffer.h"
20 #include "clang/Tooling/ArgumentsAdjusters.h"
21 #include "clang/Tooling/CompilationDatabase.h"
22 #include "llvm/ADT/STLExtras.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/MC/TargetRegistry.h"
25 #include "llvm/Support/Host.h"
26 #include "llvm/Support/Path.h"
27 #include "llvm/Support/TargetSelect.h"
28 #include "gtest/gtest.h"
29 #include <algorithm>
30 #include <string>
31 #include <vector>
32 
33 namespace clang {
34 namespace tooling {
35 
36 namespace {
37 /// Takes an ast consumer and returns it from CreateASTConsumer. This only
38 /// works with single translation unit compilations.
39 class TestAction : public clang::ASTFrontendAction {
40 public:
41   /// Takes ownership of TestConsumer.
42   explicit TestAction(std::unique_ptr<clang::ASTConsumer> TestConsumer)
43       : TestConsumer(std::move(TestConsumer)) {}
44 
45 protected:
46   std::unique_ptr<clang::ASTConsumer>
47   CreateASTConsumer(clang::CompilerInstance &compiler,
48                     StringRef dummy) override {
49     /// TestConsumer will be deleted by the framework calling us.
50     return std::move(TestConsumer);
51   }
52 
53 private:
54   std::unique_ptr<clang::ASTConsumer> TestConsumer;
55 };
56 
57 class FindTopLevelDeclConsumer : public clang::ASTConsumer {
58  public:
59   explicit FindTopLevelDeclConsumer(bool *FoundTopLevelDecl)
60       : FoundTopLevelDecl(FoundTopLevelDecl) {}
61   bool HandleTopLevelDecl(clang::DeclGroupRef DeclGroup) override {
62     *FoundTopLevelDecl = true;
63     return true;
64   }
65  private:
66   bool * const FoundTopLevelDecl;
67 };
68 } // end namespace
69 
70 TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) {
71   bool FoundTopLevelDecl = false;
72   EXPECT_TRUE(runToolOnCode(
73       std::make_unique<TestAction>(
74           std::make_unique<FindTopLevelDeclConsumer>(&FoundTopLevelDecl)),
75       ""));
76   EXPECT_FALSE(FoundTopLevelDecl);
77 }
78 
79 namespace {
80 class FindClassDeclXConsumer : public clang::ASTConsumer {
81  public:
82   FindClassDeclXConsumer(bool *FoundClassDeclX)
83       : FoundClassDeclX(FoundClassDeclX) {}
84   bool HandleTopLevelDecl(clang::DeclGroupRef GroupRef) override {
85     if (CXXRecordDecl* Record = dyn_cast<clang::CXXRecordDecl>(
86             *GroupRef.begin())) {
87       if (Record->getName() == "X") {
88         *FoundClassDeclX = true;
89       }
90     }
91     return true;
92   }
93  private:
94   bool *FoundClassDeclX;
95 };
96 bool FindClassDeclX(ASTUnit *AST) {
97   for (std::vector<Decl *>::iterator i = AST->top_level_begin(),
98                                      e = AST->top_level_end();
99        i != e; ++i) {
100     if (CXXRecordDecl* Record = dyn_cast<clang::CXXRecordDecl>(*i)) {
101       if (Record->getName() == "X") {
102         return true;
103       }
104     }
105   }
106   return false;
107 }
108 
109 struct TestDiagnosticConsumer : public DiagnosticConsumer {
110   TestDiagnosticConsumer() : NumDiagnosticsSeen(0) {}
111   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
112                         const Diagnostic &Info) override {
113     ++NumDiagnosticsSeen;
114   }
115   unsigned NumDiagnosticsSeen;
116 };
117 } // end namespace
118 
119 TEST(runToolOnCode, FindsClassDecl) {
120   bool FoundClassDeclX = false;
121   EXPECT_TRUE(runToolOnCode(
122       std::make_unique<TestAction>(
123           std::make_unique<FindClassDeclXConsumer>(&FoundClassDeclX)),
124       "class X;"));
125   EXPECT_TRUE(FoundClassDeclX);
126 
127   FoundClassDeclX = false;
128   EXPECT_TRUE(runToolOnCode(
129       std::make_unique<TestAction>(
130           std::make_unique<FindClassDeclXConsumer>(&FoundClassDeclX)),
131       "class Y;"));
132   EXPECT_FALSE(FoundClassDeclX);
133 }
134 
135 TEST(buildASTFromCode, FindsClassDecl) {
136   std::unique_ptr<ASTUnit> AST = buildASTFromCode("class X;");
137   ASSERT_TRUE(AST.get());
138   EXPECT_TRUE(FindClassDeclX(AST.get()));
139 
140   AST = buildASTFromCode("class Y;");
141   ASSERT_TRUE(AST.get());
142   EXPECT_FALSE(FindClassDeclX(AST.get()));
143 }
144 
145 TEST(buildASTFromCode, ReportsErrors) {
146   TestDiagnosticConsumer Consumer;
147   std::unique_ptr<ASTUnit> AST = buildASTFromCodeWithArgs(
148       "int x = \"A\";", {}, "input.cc", "clang-tool",
149       std::make_shared<PCHContainerOperations>(),
150       getClangStripDependencyFileAdjuster(), FileContentMappings(), &Consumer);
151   EXPECT_TRUE(AST.get());
152   EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
153 }
154 
155 TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) {
156   std::unique_ptr<FrontendActionFactory> Factory(
157       newFrontendActionFactory<SyntaxOnlyAction>());
158   std::unique_ptr<FrontendAction> Action(Factory->create());
159   EXPECT_TRUE(Action.get() != nullptr);
160 }
161 
162 struct IndependentFrontendActionCreator {
163   std::unique_ptr<ASTConsumer> newASTConsumer() {
164     return std::make_unique<FindTopLevelDeclConsumer>(nullptr);
165   }
166 };
167 
168 TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromFactoryType) {
169   IndependentFrontendActionCreator Creator;
170   std::unique_ptr<FrontendActionFactory> Factory(
171       newFrontendActionFactory(&Creator));
172   std::unique_ptr<FrontendAction> Action(Factory->create());
173   EXPECT_TRUE(Action.get() != nullptr);
174 }
175 
176 TEST(ToolInvocation, TestMapVirtualFile) {
177   llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFileSystem(
178       new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));
179   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
180       new llvm::vfs::InMemoryFileSystem);
181   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
182   llvm::IntrusiveRefCntPtr<FileManager> Files(
183       new FileManager(FileSystemOptions(), OverlayFileSystem));
184   std::vector<std::string> Args;
185   Args.push_back("tool-executable");
186   Args.push_back("-Idef");
187   Args.push_back("-fsyntax-only");
188   Args.push_back("test.cpp");
189   clang::tooling::ToolInvocation Invocation(
190       Args, std::make_unique<SyntaxOnlyAction>(), Files.get());
191   InMemoryFileSystem->addFile(
192       "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include <abc>\n"));
193   InMemoryFileSystem->addFile("def/abc", 0,
194                               llvm::MemoryBuffer::getMemBuffer("\n"));
195   EXPECT_TRUE(Invocation.run());
196 }
197 
198 TEST(ToolInvocation, TestVirtualModulesCompilation) {
199   // FIXME: Currently, this only tests that we don't exit with an error if a
200   // mapped module.map is found on the include path. In the future, expand this
201   // test to run a full modules enabled compilation, so we make sure we can
202   // rerun modules compilations with a virtual file system.
203   llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFileSystem(
204       new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));
205   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
206       new llvm::vfs::InMemoryFileSystem);
207   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
208   llvm::IntrusiveRefCntPtr<FileManager> Files(
209       new FileManager(FileSystemOptions(), OverlayFileSystem));
210   std::vector<std::string> Args;
211   Args.push_back("tool-executable");
212   Args.push_back("-Idef");
213   Args.push_back("-fsyntax-only");
214   Args.push_back("test.cpp");
215   clang::tooling::ToolInvocation Invocation(
216       Args, std::make_unique<SyntaxOnlyAction>(), Files.get());
217   InMemoryFileSystem->addFile(
218       "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include <abc>\n"));
219   InMemoryFileSystem->addFile("def/abc", 0,
220                               llvm::MemoryBuffer::getMemBuffer("\n"));
221   // Add a module.map file in the include directory of our header, so we trigger
222   // the module.map header search logic.
223   InMemoryFileSystem->addFile("def/module.map", 0,
224                               llvm::MemoryBuffer::getMemBuffer("\n"));
225   EXPECT_TRUE(Invocation.run());
226 }
227 
228 TEST(ToolInvocation, DiagnosticsEngineProperlyInitializedForCC1Construction) {
229   llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFileSystem(
230       new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));
231   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
232       new llvm::vfs::InMemoryFileSystem);
233   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
234   llvm::IntrusiveRefCntPtr<FileManager> Files(
235       new FileManager(FileSystemOptions(), OverlayFileSystem));
236 
237   std::vector<std::string> Args;
238   Args.push_back("tool-executable");
239   // Unknown warning option will result in a warning.
240   Args.push_back("-fexpensive-optimizations");
241   // Argument that will suppress the warning above.
242   Args.push_back("-Wno-ignored-optimization-argument");
243   Args.push_back("-E");
244   Args.push_back("test.cpp");
245 
246   clang::tooling::ToolInvocation Invocation(
247       Args, std::make_unique<SyntaxOnlyAction>(), Files.get());
248   InMemoryFileSystem->addFile("test.cpp", 0,
249                               llvm::MemoryBuffer::getMemBuffer(""));
250   TextDiagnosticBuffer Consumer;
251   Invocation.setDiagnosticConsumer(&Consumer);
252   EXPECT_TRUE(Invocation.run());
253   // Check that the warning was ignored due to the '-Wno-xxx' argument.
254   EXPECT_EQ(std::distance(Consumer.warn_begin(), Consumer.warn_end()), 0u);
255 }
256 
257 TEST(ToolInvocation, CustomDiagnosticOptionsOverwriteParsedOnes) {
258   llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFileSystem(
259       new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));
260   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
261       new llvm::vfs::InMemoryFileSystem);
262   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
263   llvm::IntrusiveRefCntPtr<FileManager> Files(
264       new FileManager(FileSystemOptions(), OverlayFileSystem));
265 
266   std::vector<std::string> Args;
267   Args.push_back("tool-executable");
268   // Unknown warning option will result in a warning.
269   Args.push_back("-fexpensive-optimizations");
270   // Argument that will suppress the warning above.
271   Args.push_back("-Wno-ignored-optimization-argument");
272   Args.push_back("-E");
273   Args.push_back("test.cpp");
274 
275   clang::tooling::ToolInvocation Invocation(
276       Args, std::make_unique<SyntaxOnlyAction>(), Files.get());
277   InMemoryFileSystem->addFile("test.cpp", 0,
278                               llvm::MemoryBuffer::getMemBuffer(""));
279   TextDiagnosticBuffer Consumer;
280   Invocation.setDiagnosticConsumer(&Consumer);
281 
282   // Inject custom `DiagnosticOptions` for command-line parsing.
283   auto DiagOpts = llvm::makeIntrusiveRefCnt<DiagnosticOptions>();
284   Invocation.setDiagnosticOptions(&*DiagOpts);
285 
286   EXPECT_TRUE(Invocation.run());
287   // Check that the warning was issued during command-line parsing due to the
288   // custom `DiagnosticOptions` without '-Wno-xxx'.
289   EXPECT_EQ(std::distance(Consumer.warn_begin(), Consumer.warn_end()), 1u);
290 }
291 
292 struct DiagnosticConsumerExpectingSourceManager : public DiagnosticConsumer {
293   bool SawSourceManager;
294 
295   DiagnosticConsumerExpectingSourceManager() : SawSourceManager(false) {}
296 
297   void HandleDiagnostic(clang::DiagnosticsEngine::Level,
298                         const clang::Diagnostic &info) override {
299     SawSourceManager = info.hasSourceManager();
300   }
301 };
302 
303 TEST(ToolInvocation, DiagConsumerExpectingSourceManager) {
304   llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFileSystem(
305       new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));
306   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
307       new llvm::vfs::InMemoryFileSystem);
308   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
309   llvm::IntrusiveRefCntPtr<FileManager> Files(
310       new FileManager(FileSystemOptions(), OverlayFileSystem));
311   std::vector<std::string> Args;
312   Args.push_back("tool-executable");
313   // Note: intentional error; user probably meant -ferror-limit=0.
314   Args.push_back("-ferror-limit=-1");
315   Args.push_back("-fsyntax-only");
316   Args.push_back("test.cpp");
317   clang::tooling::ToolInvocation Invocation(
318       Args, std::make_unique<SyntaxOnlyAction>(), Files.get());
319   InMemoryFileSystem->addFile(
320       "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int main() {}\n"));
321 
322   DiagnosticConsumerExpectingSourceManager Consumer;
323   Invocation.setDiagnosticConsumer(&Consumer);
324 
325   EXPECT_TRUE(Invocation.run());
326   EXPECT_TRUE(Consumer.SawSourceManager);
327 }
328 
329 namespace {
330 /// Overlays the real filesystem with the given VFS and returns the result.
331 llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem>
332 overlayRealFS(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
333   auto RFS = llvm::vfs::getRealFileSystem();
334   auto OverlayFS = llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>(RFS);
335   OverlayFS->pushOverlay(VFS);
336   return OverlayFS;
337 }
338 
339 struct CommandLineExtractorTest : public ::testing::Test {
340   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFS;
341   llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
342   driver::Driver Driver;
343 
344 public:
345   CommandLineExtractorTest()
346       : InMemoryFS(new llvm::vfs::InMemoryFileSystem),
347         Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions)),
348         Driver("clang", llvm::sys::getDefaultTargetTriple(), *Diags,
349                "clang LLVM compiler", overlayRealFS(InMemoryFS)) {}
350 
351   void addFile(StringRef Name, StringRef Content) {
352     InMemoryFS->addFile(Name, 0, llvm::MemoryBuffer::getMemBuffer(Content));
353   }
354 
355   const llvm::opt::ArgStringList *
356   extractCC1Arguments(llvm::ArrayRef<const char *> Argv) {
357     const std::unique_ptr<driver::Compilation> Compilation(
358         Driver.BuildCompilation(llvm::makeArrayRef(Argv)));
359 
360     return getCC1Arguments(Diags.get(), Compilation.get());
361   }
362 };
363 } // namespace
364 
365 TEST_F(CommandLineExtractorTest, AcceptOffloading) {
366   addFile("test.c", "int main() {}\n");
367   const char *Args[] = {"clang",     "-target",  "arm64-apple-macosx11.0.0",
368                         "-x",        "hip",      "test.c",
369                         "-nogpulib", "-nogpuinc"};
370   EXPECT_NE(extractCC1Arguments(Args), nullptr);
371 }
372 
373 TEST_F(CommandLineExtractorTest, AcceptOffloadingCompile) {
374   addFile("test.c", "int main() {}\n");
375   const char *Args[] = {"clang",  "-target",   "arm64-apple-macosx11.0.0",
376                         "-c",     "-x",        "hip",
377                         "test.c", "-nogpulib", "-nogpuinc"};
378   EXPECT_NE(extractCC1Arguments(Args), nullptr);
379 }
380 
381 TEST_F(CommandLineExtractorTest, AcceptOffloadingSyntaxOnly) {
382   addFile("test.c", "int main() {}\n");
383   const char *Args[] = {
384       "clang",         "-target",   "arm64-apple-macosx11.0.0",
385       "-fsyntax-only", "-x",        "hip",
386       "test.c",        "-nogpulib", "-nogpuinc"};
387   EXPECT_NE(extractCC1Arguments(Args), nullptr);
388 }
389 
390 TEST_F(CommandLineExtractorTest, AcceptExternalAssembler) {
391   addFile("test.c", "int main() {}\n");
392   const char *Args[] = {
393       "clang", "-target", "arm64-apple-macosx11.0.0", "-fno-integrated-as",
394       "-c",    "test.c"};
395   EXPECT_NE(extractCC1Arguments(Args), nullptr);
396 }
397 
398 TEST_F(CommandLineExtractorTest, AcceptEmbedBitcode) {
399   addFile("test.c", "int main() {}\n");
400   const char *Args[] = {"clang", "-target",         "arm64-apple-macosx11.0.0",
401                         "-c",    "-fembed-bitcode", "test.c"};
402   EXPECT_NE(extractCC1Arguments(Args), nullptr);
403 }
404 
405 TEST_F(CommandLineExtractorTest, AcceptSaveTemps) {
406   addFile("test.c", "int main() {}\n");
407   const char *Args[] = {"clang", "-target",     "arm64-apple-macosx11.0.0",
408                         "-c",    "-save-temps", "test.c"};
409   EXPECT_NE(extractCC1Arguments(Args), nullptr);
410 }
411 
412 TEST_F(CommandLineExtractorTest, RejectMultipleArchitectures) {
413   addFile("test.c", "int main() {}\n");
414   const char *Args[] = {"clang", "-target", "arm64-apple-macosx11.0.0",
415                         "-arch", "x86_64",  "-arch",
416                         "arm64", "-c",      "test.c"};
417   EXPECT_EQ(extractCC1Arguments(Args), nullptr);
418 }
419 
420 TEST_F(CommandLineExtractorTest, RejectMultipleInputFiles) {
421   addFile("one.c", "void one() {}\n");
422   addFile("two.c", "void two() {}\n");
423   const char *Args[] = {"clang", "-target", "arm64-apple-macosx11.0.0",
424                         "-c",    "one.c",   "two.c"};
425   EXPECT_EQ(extractCC1Arguments(Args), nullptr);
426 }
427 
428 struct VerifyEndCallback : public SourceFileCallbacks {
429   VerifyEndCallback() : BeginCalled(0), EndCalled(0), Matched(false) {}
430   bool handleBeginSource(CompilerInstance &CI) override {
431     ++BeginCalled;
432     return true;
433   }
434   void handleEndSource() override { ++EndCalled; }
435   std::unique_ptr<ASTConsumer> newASTConsumer() {
436     return std::make_unique<FindTopLevelDeclConsumer>(&Matched);
437   }
438   unsigned BeginCalled;
439   unsigned EndCalled;
440   bool Matched;
441 };
442 
443 #if !defined(_WIN32)
444 TEST(newFrontendActionFactory, InjectsSourceFileCallbacks) {
445   VerifyEndCallback EndCallback;
446 
447   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
448   std::vector<std::string> Sources;
449   Sources.push_back("/a.cc");
450   Sources.push_back("/b.cc");
451   ClangTool Tool(Compilations, Sources);
452 
453   Tool.mapVirtualFile("/a.cc", "void a() {}");
454   Tool.mapVirtualFile("/b.cc", "void b() {}");
455 
456   std::unique_ptr<FrontendActionFactory> Action(
457       newFrontendActionFactory(&EndCallback, &EndCallback));
458   Tool.run(Action.get());
459 
460   EXPECT_TRUE(EndCallback.Matched);
461   EXPECT_EQ(2u, EndCallback.BeginCalled);
462   EXPECT_EQ(2u, EndCallback.EndCalled);
463 }
464 #endif
465 
466 struct SkipBodyConsumer : public clang::ASTConsumer {
467   /// Skip the 'skipMe' function.
468   bool shouldSkipFunctionBody(Decl *D) override {
469     NamedDecl *F = dyn_cast<NamedDecl>(D);
470     return F && F->getNameAsString() == "skipMe";
471   }
472 };
473 
474 struct SkipBodyAction : public clang::ASTFrontendAction {
475   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
476                                                  StringRef) override {
477     Compiler.getFrontendOpts().SkipFunctionBodies = true;
478     return std::make_unique<SkipBodyConsumer>();
479   }
480 };
481 
482 TEST(runToolOnCode, TestSkipFunctionBody) {
483   std::vector<std::string> Args = {"-std=c++11"};
484   std::vector<std::string> Args2 = {"-fno-delayed-template-parsing"};
485 
486   EXPECT_TRUE(runToolOnCode(std::make_unique<SkipBodyAction>(),
487                             "int skipMe() { an_error_here }"));
488   EXPECT_FALSE(runToolOnCode(std::make_unique<SkipBodyAction>(),
489                              "int skipMeNot() { an_error_here }"));
490 
491   // Test constructors with initializers
492   EXPECT_TRUE(runToolOnCodeWithArgs(
493       std::make_unique<SkipBodyAction>(),
494       "struct skipMe { skipMe() : an_error() { more error } };", Args));
495   EXPECT_TRUE(runToolOnCodeWithArgs(
496       std::make_unique<SkipBodyAction>(), "struct skipMe { skipMe(); };"
497                           "skipMe::skipMe() : an_error([](){;}) { more error }",
498       Args));
499   EXPECT_TRUE(runToolOnCodeWithArgs(
500       std::make_unique<SkipBodyAction>(), "struct skipMe { skipMe(); };"
501                           "skipMe::skipMe() : an_error{[](){;}} { more error }",
502       Args));
503   EXPECT_TRUE(runToolOnCodeWithArgs(
504       std::make_unique<SkipBodyAction>(),
505       "struct skipMe { skipMe(); };"
506       "skipMe::skipMe() : a<b<c>(e)>>(), f{}, g() { error }",
507       Args));
508   EXPECT_TRUE(runToolOnCodeWithArgs(
509       std::make_unique<SkipBodyAction>(), "struct skipMe { skipMe() : bases()... { error } };",
510       Args));
511 
512   EXPECT_FALSE(runToolOnCodeWithArgs(
513       std::make_unique<SkipBodyAction>(), "struct skipMeNot { skipMeNot() : an_error() { } };",
514       Args));
515   EXPECT_FALSE(runToolOnCodeWithArgs(std::make_unique<SkipBodyAction>(),
516                                      "struct skipMeNot { skipMeNot(); };"
517                                      "skipMeNot::skipMeNot() : an_error() { }",
518                                      Args));
519 
520   // Try/catch
521   EXPECT_TRUE(runToolOnCode(
522       std::make_unique<SkipBodyAction>(),
523       "void skipMe() try { an_error() } catch(error) { error };"));
524   EXPECT_TRUE(runToolOnCode(
525       std::make_unique<SkipBodyAction>(),
526       "struct S { void skipMe() try { an_error() } catch(error) { error } };"));
527   EXPECT_TRUE(
528       runToolOnCode(std::make_unique<SkipBodyAction>(),
529                     "void skipMe() try { an_error() } catch(error) { error; }"
530                     "catch(error) { error } catch (error) { }"));
531   EXPECT_FALSE(runToolOnCode(
532       std::make_unique<SkipBodyAction>(),
533       "void skipMe() try something;")); // don't crash while parsing
534 
535   // Template
536   EXPECT_TRUE(runToolOnCode(
537       std::make_unique<SkipBodyAction>(), "template<typename T> int skipMe() { an_error_here }"
538                           "int x = skipMe<int>();"));
539   EXPECT_FALSE(runToolOnCodeWithArgs(
540       std::make_unique<SkipBodyAction>(),
541       "template<typename T> int skipMeNot() { an_error_here }", Args2));
542 }
543 
544 TEST(runToolOnCodeWithArgs, TestNoDepFile) {
545   llvm::SmallString<32> DepFilePath;
546   ASSERT_FALSE(llvm::sys::fs::getPotentiallyUniqueTempFileName("depfile", "d",
547                                                                DepFilePath));
548   std::vector<std::string> Args;
549   Args.push_back("-MMD");
550   Args.push_back("-MT");
551   Args.push_back(std::string(DepFilePath.str()));
552   Args.push_back("-MF");
553   Args.push_back(std::string(DepFilePath.str()));
554   EXPECT_TRUE(runToolOnCodeWithArgs(std::make_unique<SkipBodyAction>(), "", Args));
555   EXPECT_FALSE(llvm::sys::fs::exists(DepFilePath.str()));
556   EXPECT_FALSE(llvm::sys::fs::remove(DepFilePath.str()));
557 }
558 
559 struct CheckColoredDiagnosticsAction : public clang::ASTFrontendAction {
560   CheckColoredDiagnosticsAction(bool ShouldShowColor)
561       : ShouldShowColor(ShouldShowColor) {}
562   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
563                                                  StringRef) override {
564     if (Compiler.getDiagnosticOpts().ShowColors != ShouldShowColor)
565       Compiler.getDiagnostics().Report(
566           Compiler.getDiagnostics().getCustomDiagID(
567               DiagnosticsEngine::Fatal,
568               "getDiagnosticOpts().ShowColors != ShouldShowColor"));
569     return std::make_unique<ASTConsumer>();
570   }
571 
572 private:
573   bool ShouldShowColor = true;
574 };
575 
576 TEST(runToolOnCodeWithArgs, DiagnosticsColor) {
577   EXPECT_TRUE(runToolOnCodeWithArgs(
578       std::make_unique<CheckColoredDiagnosticsAction>(true), "",
579       {"-fcolor-diagnostics"}));
580   EXPECT_TRUE(runToolOnCodeWithArgs(
581       std::make_unique<CheckColoredDiagnosticsAction>(false), "",
582       {"-fno-color-diagnostics"}));
583   EXPECT_TRUE(runToolOnCodeWithArgs(
584       std::make_unique<CheckColoredDiagnosticsAction>(true), "",
585       {"-fno-color-diagnostics", "-fcolor-diagnostics"}));
586   EXPECT_TRUE(runToolOnCodeWithArgs(
587       std::make_unique<CheckColoredDiagnosticsAction>(false), "",
588       {"-fcolor-diagnostics", "-fno-color-diagnostics"}));
589   EXPECT_TRUE(runToolOnCodeWithArgs(
590       std::make_unique<CheckColoredDiagnosticsAction>(true), "",
591       {"-fno-color-diagnostics", "-fdiagnostics-color=always"}));
592 
593   // Check that this test would fail if ShowColors is not what it should.
594   EXPECT_FALSE(runToolOnCodeWithArgs(
595       std::make_unique<CheckColoredDiagnosticsAction>(false), "",
596       {"-fcolor-diagnostics"}));
597 }
598 
599 TEST(ClangToolTest, ArgumentAdjusters) {
600   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
601 
602   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
603   Tool.mapVirtualFile("/a.cc", "void a() {}");
604 
605   std::unique_ptr<FrontendActionFactory> Action(
606       newFrontendActionFactory<SyntaxOnlyAction>());
607 
608   bool Found = false;
609   bool Ran = false;
610   ArgumentsAdjuster CheckSyntaxOnlyAdjuster =
611       [&Found, &Ran](const CommandLineArguments &Args, StringRef /*unused*/) {
612     Ran = true;
613     if (llvm::is_contained(Args, "-fsyntax-only"))
614       Found = true;
615     return Args;
616   };
617   Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster);
618   Tool.run(Action.get());
619   EXPECT_TRUE(Ran);
620   EXPECT_TRUE(Found);
621 
622   Ran = Found = false;
623   Tool.clearArgumentsAdjusters();
624   Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster);
625   Tool.appendArgumentsAdjuster(getClangSyntaxOnlyAdjuster());
626   Tool.run(Action.get());
627   EXPECT_TRUE(Ran);
628   EXPECT_FALSE(Found);
629 }
630 
631 TEST(ClangToolTest, NoDoubleSyntaxOnly) {
632   FixedCompilationDatabase Compilations("/", {"-fsyntax-only"});
633 
634   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
635   Tool.mapVirtualFile("/a.cc", "void a() {}");
636 
637   std::unique_ptr<FrontendActionFactory> Action(
638       newFrontendActionFactory<SyntaxOnlyAction>());
639 
640   size_t SyntaxOnlyCount = 0;
641   ArgumentsAdjuster CheckSyntaxOnlyAdjuster =
642       [&SyntaxOnlyCount](const CommandLineArguments &Args,
643                          StringRef /*unused*/) {
644         for (llvm::StringRef Arg : Args) {
645           if (Arg == "-fsyntax-only")
646             ++SyntaxOnlyCount;
647         }
648         return Args;
649       };
650 
651   Tool.clearArgumentsAdjusters();
652   Tool.appendArgumentsAdjuster(getClangSyntaxOnlyAdjuster());
653   Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster);
654   Tool.run(Action.get());
655   EXPECT_EQ(SyntaxOnlyCount, 1U);
656 }
657 
658 TEST(ClangToolTest, NoOutputCommands) {
659   FixedCompilationDatabase Compilations("/", {"-save-temps", "-save-temps=cwd",
660                                               "--save-temps",
661                                               "--save-temps=somedir"});
662 
663   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
664   Tool.mapVirtualFile("/a.cc", "void a() {}");
665 
666   std::unique_ptr<FrontendActionFactory> Action(
667       newFrontendActionFactory<SyntaxOnlyAction>());
668 
669   const std::vector<llvm::StringRef> OutputCommands = {"-save-temps"};
670   bool Ran = false;
671   ArgumentsAdjuster CheckSyntaxOnlyAdjuster =
672       [&OutputCommands, &Ran](const CommandLineArguments &Args,
673                               StringRef /*unused*/) {
674         for (llvm::StringRef Arg : Args) {
675           for (llvm::StringRef OutputCommand : OutputCommands)
676             EXPECT_FALSE(Arg.contains(OutputCommand));
677         }
678         Ran = true;
679         return Args;
680       };
681 
682   Tool.clearArgumentsAdjusters();
683   Tool.appendArgumentsAdjuster(getClangSyntaxOnlyAdjuster());
684   Tool.appendArgumentsAdjuster(CheckSyntaxOnlyAdjuster);
685   Tool.run(Action.get());
686   EXPECT_TRUE(Ran);
687 }
688 
689 TEST(ClangToolTest, BaseVirtualFileSystemUsage) {
690   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
691   llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFileSystem(
692       new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));
693   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
694       new llvm::vfs::InMemoryFileSystem);
695   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
696 
697   InMemoryFileSystem->addFile(
698       "a.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int main() {}"));
699 
700   ClangTool Tool(Compilations, std::vector<std::string>(1, "a.cpp"),
701                  std::make_shared<PCHContainerOperations>(), OverlayFileSystem);
702   std::unique_ptr<FrontendActionFactory> Action(
703       newFrontendActionFactory<SyntaxOnlyAction>());
704   EXPECT_EQ(0, Tool.run(Action.get()));
705 }
706 
707 // Check getClangStripDependencyFileAdjuster doesn't strip args after -MD/-MMD.
708 TEST(ClangToolTest, StripDependencyFileAdjuster) {
709   FixedCompilationDatabase Compilations("/", {"-MD", "-c", "-MMD", "-w"});
710 
711   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
712   Tool.mapVirtualFile("/a.cc", "void a() {}");
713 
714   std::unique_ptr<FrontendActionFactory> Action(
715       newFrontendActionFactory<SyntaxOnlyAction>());
716 
717   CommandLineArguments FinalArgs;
718   ArgumentsAdjuster CheckFlagsAdjuster =
719     [&FinalArgs](const CommandLineArguments &Args, StringRef /*unused*/) {
720       FinalArgs = Args;
721       return Args;
722     };
723   Tool.clearArgumentsAdjusters();
724   Tool.appendArgumentsAdjuster(getClangStripDependencyFileAdjuster());
725   Tool.appendArgumentsAdjuster(CheckFlagsAdjuster);
726   Tool.run(Action.get());
727 
728   auto HasFlag = [&FinalArgs](const std::string &Flag) {
729     return llvm::find(FinalArgs, Flag) != FinalArgs.end();
730   };
731   EXPECT_FALSE(HasFlag("-MD"));
732   EXPECT_FALSE(HasFlag("-MMD"));
733   EXPECT_TRUE(HasFlag("-c"));
734   EXPECT_TRUE(HasFlag("-w"));
735 }
736 
737 // Check getClangStripDependencyFileAdjuster strips /showIncludes and variants
738 TEST(ClangToolTest, StripDependencyFileAdjusterShowIncludes) {
739   FixedCompilationDatabase Compilations(
740       "/", {"/showIncludes", "/showIncludes:user", "-showIncludes",
741             "-showIncludes:user", "-c"});
742 
743   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
744   Tool.mapVirtualFile("/a.cc", "void a() {}");
745 
746   std::unique_ptr<FrontendActionFactory> Action(
747       newFrontendActionFactory<SyntaxOnlyAction>());
748 
749   CommandLineArguments FinalArgs;
750   ArgumentsAdjuster CheckFlagsAdjuster =
751       [&FinalArgs](const CommandLineArguments &Args, StringRef /*unused*/) {
752         FinalArgs = Args;
753         return Args;
754       };
755   Tool.clearArgumentsAdjusters();
756   Tool.appendArgumentsAdjuster(getClangStripDependencyFileAdjuster());
757   Tool.appendArgumentsAdjuster(CheckFlagsAdjuster);
758   Tool.run(Action.get());
759 
760   auto HasFlag = [&FinalArgs](const std::string &Flag) {
761     return llvm::find(FinalArgs, Flag) != FinalArgs.end();
762   };
763   EXPECT_FALSE(HasFlag("/showIncludes"));
764   EXPECT_FALSE(HasFlag("/showIncludes:user"));
765   EXPECT_FALSE(HasFlag("-showIncludes"));
766   EXPECT_FALSE(HasFlag("-showIncludes:user"));
767   EXPECT_TRUE(HasFlag("-c"));
768 }
769 
770 // Check getClangStripDependencyFileAdjuster doesn't strip args when using the
771 // MSVC cl.exe driver
772 TEST(ClangToolTest, StripDependencyFileAdjusterMsvc) {
773   FixedCompilationDatabase Compilations(
774       "/", {"--driver-mode=cl", "-MD", "-MDd", "-MT", "-O1", "-MTd", "-MP"});
775 
776   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
777   Tool.mapVirtualFile("/a.cc", "void a() {}");
778 
779   std::unique_ptr<FrontendActionFactory> Action(
780       newFrontendActionFactory<SyntaxOnlyAction>());
781 
782   CommandLineArguments FinalArgs;
783   ArgumentsAdjuster CheckFlagsAdjuster =
784       [&FinalArgs](const CommandLineArguments &Args, StringRef /*unused*/) {
785         FinalArgs = Args;
786         return Args;
787       };
788   Tool.clearArgumentsAdjusters();
789   Tool.appendArgumentsAdjuster(getClangStripDependencyFileAdjuster());
790   Tool.appendArgumentsAdjuster(CheckFlagsAdjuster);
791   Tool.run(Action.get());
792 
793   auto HasFlag = [&FinalArgs](const std::string &Flag) {
794     return llvm::find(FinalArgs, Flag) != FinalArgs.end();
795   };
796   EXPECT_TRUE(HasFlag("-MD"));
797   EXPECT_TRUE(HasFlag("-MDd"));
798   EXPECT_TRUE(HasFlag("-MT"));
799   EXPECT_TRUE(HasFlag("-O1"));
800   EXPECT_TRUE(HasFlag("-MTd"));
801   EXPECT_TRUE(HasFlag("-MP"));
802 }
803 
804 // Check getClangStripPluginsAdjuster strips plugin related args.
805 TEST(ClangToolTest, StripPluginsAdjuster) {
806   FixedCompilationDatabase Compilations(
807       "/", {"-Xclang", "-add-plugin", "-Xclang", "random-plugin"});
808 
809   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
810   Tool.mapVirtualFile("/a.cc", "void a() {}");
811 
812   std::unique_ptr<FrontendActionFactory> Action(
813       newFrontendActionFactory<SyntaxOnlyAction>());
814 
815   CommandLineArguments FinalArgs;
816   ArgumentsAdjuster CheckFlagsAdjuster =
817       [&FinalArgs](const CommandLineArguments &Args, StringRef /*unused*/) {
818         FinalArgs = Args;
819         return Args;
820       };
821   Tool.clearArgumentsAdjusters();
822   Tool.appendArgumentsAdjuster(getStripPluginsAdjuster());
823   Tool.appendArgumentsAdjuster(CheckFlagsAdjuster);
824   Tool.run(Action.get());
825 
826   auto HasFlag = [&FinalArgs](const std::string &Flag) {
827     return llvm::find(FinalArgs, Flag) != FinalArgs.end();
828   };
829   EXPECT_FALSE(HasFlag("-Xclang"));
830   EXPECT_FALSE(HasFlag("-add-plugin"));
831   EXPECT_FALSE(HasFlag("-random-plugin"));
832 }
833 
834 namespace {
835 /// Find a target name such that looking for it in TargetRegistry by that name
836 /// returns the same target. We expect that there is at least one target
837 /// configured with this property.
838 std::string getAnyTarget() {
839   llvm::InitializeAllTargets();
840   for (const auto &Target : llvm::TargetRegistry::targets()) {
841     std::string Error;
842     StringRef TargetName(Target.getName());
843     if (TargetName == "x86-64")
844       TargetName = "x86_64";
845     if (llvm::TargetRegistry::lookupTarget(std::string(TargetName), Error) ==
846         &Target) {
847       return std::string(TargetName);
848     }
849   }
850   return "";
851 }
852 }
853 
854 TEST(addTargetAndModeForProgramName, AddsTargetAndMode) {
855   std::string Target = getAnyTarget();
856   ASSERT_FALSE(Target.empty());
857 
858   std::vector<std::string> Args = {"clang", "-foo"};
859   addTargetAndModeForProgramName(Args, "");
860   EXPECT_EQ((std::vector<std::string>{"clang", "-foo"}), Args);
861   addTargetAndModeForProgramName(Args, Target + "-g++");
862   EXPECT_EQ((std::vector<std::string>{"clang", "--target=" + Target,
863                                       "--driver-mode=g++", "-foo"}),
864             Args);
865 }
866 
867 TEST(addTargetAndModeForProgramName, PathIgnored) {
868   std::string Target = getAnyTarget();
869   ASSERT_FALSE(Target.empty());
870 
871   SmallString<32> ToolPath;
872   llvm::sys::path::append(ToolPath, "foo", "bar", Target + "-g++");
873 
874   std::vector<std::string> Args = {"clang", "-foo"};
875   addTargetAndModeForProgramName(Args, ToolPath);
876   EXPECT_EQ((std::vector<std::string>{"clang", "--target=" + Target,
877                                       "--driver-mode=g++", "-foo"}),
878             Args);
879 }
880 
881 TEST(addTargetAndModeForProgramName, IgnoresExistingTarget) {
882   std::string Target = getAnyTarget();
883   ASSERT_FALSE(Target.empty());
884 
885   std::vector<std::string> Args = {"clang", "-foo", "-target", "something"};
886   addTargetAndModeForProgramName(Args, Target + "-g++");
887   EXPECT_EQ((std::vector<std::string>{"clang", "--driver-mode=g++", "-foo",
888                                       "-target", "something"}),
889             Args);
890 
891   std::vector<std::string> ArgsAlt = {"clang", "-foo", "--target=something"};
892   addTargetAndModeForProgramName(ArgsAlt, Target + "-g++");
893   EXPECT_EQ((std::vector<std::string>{"clang", "--driver-mode=g++", "-foo",
894                                       "--target=something"}),
895             ArgsAlt);
896 }
897 
898 TEST(addTargetAndModeForProgramName, IgnoresExistingMode) {
899   std::string Target = getAnyTarget();
900   ASSERT_FALSE(Target.empty());
901 
902   std::vector<std::string> Args = {"clang", "-foo", "--driver-mode=abc"};
903   addTargetAndModeForProgramName(Args, Target + "-g++");
904   EXPECT_EQ((std::vector<std::string>{"clang", "--target=" + Target, "-foo",
905                                       "--driver-mode=abc"}),
906             Args);
907 }
908 
909 #ifndef _WIN32
910 TEST(ClangToolTest, BuildASTs) {
911   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
912 
913   std::vector<std::string> Sources;
914   Sources.push_back("/a.cc");
915   Sources.push_back("/b.cc");
916   ClangTool Tool(Compilations, Sources);
917 
918   Tool.mapVirtualFile("/a.cc", "void a() {}");
919   Tool.mapVirtualFile("/b.cc", "void b() {}");
920 
921   std::vector<std::unique_ptr<ASTUnit>> ASTs;
922   EXPECT_EQ(0, Tool.buildASTs(ASTs));
923   EXPECT_EQ(2u, ASTs.size());
924 }
925 
926 TEST(ClangToolTest, InjectDiagnosticConsumer) {
927   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
928   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
929   Tool.mapVirtualFile("/a.cc", "int x = undeclared;");
930   TestDiagnosticConsumer Consumer;
931   Tool.setDiagnosticConsumer(&Consumer);
932   std::unique_ptr<FrontendActionFactory> Action(
933       newFrontendActionFactory<SyntaxOnlyAction>());
934   Tool.run(Action.get());
935   EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
936 }
937 
938 TEST(ClangToolTest, InjectDiagnosticConsumerInBuildASTs) {
939   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
940   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
941   Tool.mapVirtualFile("/a.cc", "int x = undeclared;");
942   TestDiagnosticConsumer Consumer;
943   Tool.setDiagnosticConsumer(&Consumer);
944   std::vector<std::unique_ptr<ASTUnit>> ASTs;
945   Tool.buildASTs(ASTs);
946   EXPECT_EQ(1u, ASTs.size());
947   EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
948 }
949 #endif
950 
951 TEST(runToolOnCode, TestResetDiagnostics) {
952   // This is a tool that resets the diagnostic during the compilation.
953   struct ResetDiagnosticAction : public clang::ASTFrontendAction {
954     std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
955                                                    StringRef) override {
956       struct Consumer : public clang::ASTConsumer {
957         bool HandleTopLevelDecl(clang::DeclGroupRef D) override {
958           auto &Diags = (*D.begin())->getASTContext().getDiagnostics();
959           // Ignore any error
960           Diags.Reset();
961           // Disable warnings because computing the CFG might crash.
962           Diags.setIgnoreAllWarnings(true);
963           return true;
964         }
965       };
966       return std::make_unique<Consumer>();
967     }
968   };
969 
970   // Should not crash
971   EXPECT_FALSE(
972       runToolOnCode(std::make_unique<ResetDiagnosticAction>(),
973                     "struct Foo { Foo(int); ~Foo(); struct Fwd _fwd; };"
974                     "void func() { long x; Foo f(x); }"));
975 }
976 
977 } // end namespace tooling
978 } // end namespace clang
979