| 1 |
//===--- TestAST.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 "clang/Testing/TestAST.h" |
| 10 |
#include "clang/Basic/Diagnostic.h" |
| 11 |
#include "clang/Basic/LangOptions.h" |
| 12 |
#include "clang/Frontend/FrontendActions.h" |
| 13 |
#include "clang/Frontend/TextDiagnostic.h" |
| 14 |
#include "clang/Testing/CommandLineArgs.h" |
| 15 |
#include "llvm/ADT/ScopeExit.h" |
| 16 |
#include "llvm/Support/VirtualFileSystem.h" |
| 17 |
|
| 18 |
#include "gtest/gtest.h" |
| 19 |
|
| 20 |
namespace clang { |
| 21 |
namespace { |
| 22 |
|
| 23 |
// Captures diagnostics into a vector, optionally reporting errors to gtest. |
| 24 |
class StoreDiagnostics : public DiagnosticConsumer { |
| 25 |
std::vector<StoredDiagnostic> &Out; |
| 26 |
bool ReportErrors; |
| 27 |
LangOptions LangOpts; |
| 28 |
|
| 29 |
public: |
| 30 |
StoreDiagnostics(std::vector<StoredDiagnostic> &Out, bool ReportErrors) |
| 31 |
: Out(Out), ReportErrors(ReportErrors) {} |
| 32 |
|
| 33 |
void BeginSourceFile(const LangOptions &LangOpts, |
| 34 |
const Preprocessor *) override { |
| 35 |
this->LangOpts = LangOpts; |
| 36 |
} |
| 37 |
|
| 38 |
void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
| 39 |
const Diagnostic &Info) override { |
| 40 |
Out.emplace_back(DiagLevel, Info); |
| 41 |
if (ReportErrors && DiagLevel >= DiagnosticsEngine::Error) { |
| 42 |
std::string Text; |
| 43 |
llvm::raw_string_ostream OS(Text); |
| 44 |
TextDiagnostic Renderer(OS, LangOpts, |
| 45 |
&Info.getDiags()->getDiagnosticOptions()); |
| 46 |
Renderer.emitStoredDiagnostic(Out.back()); |
| 47 |
ADD_FAILURE() << Text; |
| 48 |
} |
| 49 |
} |
| 50 |
}; |
| 51 |
|
| 52 |
// Fills in the bits of a CompilerInstance that weren't initialized yet. |
| 53 |
// Provides "empty" ASTContext etc if we fail before parsing gets started. |
| 54 |
void createMissingComponents(CompilerInstance &Clang) { |
| 55 |
if (!Clang.hasDiagnostics()) |
| 56 |
Clang.createDiagnostics(); |
| 57 |
if (!Clang.hasFileManager()) |
| 58 |
Clang.createFileManager(); |
| 59 |
if (!Clang.hasSourceManager()) |
| 60 |
Clang.createSourceManager(Clang.getFileManager()); |
| 61 |
if (!Clang.hasTarget()) |
| 62 |
Clang.createTarget(); |
| 63 |
if (!Clang.hasPreprocessor()) |
| 64 |
Clang.createPreprocessor(TU_Complete); |
| 65 |
if (!Clang.hasASTConsumer()) |
| 66 |
Clang.setASTConsumer(std::make_unique<ASTConsumer>()); |
| 67 |
if (!Clang.hasASTContext()) |
| 68 |
Clang.createASTContext(); |
| 69 |
if (!Clang.hasSema()) |
| 70 |
Clang.createSema(TU_Complete, /*CodeCompleteConsumer=*/nullptr); |
| 71 |
} |
| 72 |
|
| 73 |
} // namespace |
| 74 |
|
| 75 |
TestAST::TestAST(const TestInputs &In) { |
| 76 |
Clang = std::make_unique<CompilerInstance>( |
| 77 |
std::make_shared<PCHContainerOperations>()); |
| 78 |
// If we don't manage to finish parsing, create CompilerInstance components |
| 79 |
// anyway so that the test will see an empty AST instead of crashing. |
| 80 |
auto RecoverFromEarlyExit = |
| 81 |
llvm::make_scope_exit([&] { createMissingComponents(*Clang); }); |
| 82 |
|
| 83 |
// Extra error conditions are reported through diagnostics, set that up first. |
| 84 |
bool ErrorOK = In.ErrorOK || llvm::StringRef(In.Code).contains("error-ok"); |
| 85 |
Clang->createDiagnostics(new StoreDiagnostics(Diagnostics, !ErrorOK)); |
| 86 |
|
| 87 |
// Parse cc1 argv, (typically [-std=c++20 input.cc]) into CompilerInvocation. |
| 88 |
std::vector<const char *> Argv; |
| 89 |
std::vector<std::string> LangArgs = getCC1ArgsForTesting(In.Language); |
| 90 |
for (const auto &S : LangArgs) |
| 91 |
Argv.push_back(S.c_str()); |
| 92 |
for (const auto &S : In.ExtraArgs) |
| 93 |
Argv.push_back(S.c_str()); |
| 94 |
std::string Filename = getFilenameForTesting(In.Language).str(); |
| 95 |
Argv.push_back(Filename.c_str()); |
| 96 |
Clang->setInvocation(std::make_unique<CompilerInvocation>()); |
| 97 |
if (!CompilerInvocation::CreateFromArgs(Clang->getInvocation(), Argv, |
| 98 |
Clang->getDiagnostics(), "clang")) { |
| 99 |
ADD_FAILURE() << "Failed to create invocation"; |
| 100 |
return; |
| 101 |
} |
| 102 |
assert(!Clang->getInvocation().getFrontendOpts().DisableFree); |
| 103 |
|
| 104 |
// Set up a VFS with only the virtual file visible. |
| 105 |
auto VFS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>(); |
| 106 |
VFS->addFile(Filename, /*ModificationTime=*/0, |
| 107 |
llvm::MemoryBuffer::getMemBufferCopy(In.Code, Filename)); |
| 108 |
for (const auto &Extra : In.ExtraFiles) |
| 109 |
VFS->addFile( |
| 110 |
Extra.getKey(), /*ModificationTime=*/0, |
| 111 |
llvm::MemoryBuffer::getMemBufferCopy(Extra.getValue(), Extra.getKey())); |
| 112 |
Clang->createFileManager(VFS); |
| 113 |
|
| 114 |
// Running the FrontendAction creates the other components: SourceManager, |
| 115 |
// Preprocessor, ASTContext, Sema. Preprocessor needs TargetInfo to be set. |
| 116 |
EXPECT_TRUE(Clang->createTarget()); |
| 117 |
Action = |
| 118 |
In.MakeAction ? In.MakeAction() : std::make_unique<SyntaxOnlyAction>(); |
| 119 |
const FrontendInputFile &Main = Clang->getFrontendOpts().Inputs.front(); |
| 120 |
if (!Action->BeginSourceFile(*Clang, Main)) { |
| 121 |
ADD_FAILURE() << "Failed to BeginSourceFile()"; |
| 122 |
Action.reset(); // Don't call EndSourceFile if BeginSourceFile failed. |
| 123 |
return; |
| 124 |
} |
| 125 |
if (auto Err = Action->Execute()) |
| 126 |
ADD_FAILURE() << "Failed to Execute(): " << llvm::toString(std::move(Err)); |
| 127 |
|
| 128 |
// Action->EndSourceFile() would destroy the ASTContext, we want to keep it. |
| 129 |
// But notify the preprocessor we're done now. |
| 130 |
Clang->getPreprocessor().EndSourceFile(); |
| 131 |
// We're done gathering diagnostics, detach the consumer so we can destroy it. |
| 132 |
Clang->getDiagnosticClient().EndSourceFile(); |
| 133 |
Clang->getDiagnostics().setClient(new DiagnosticConsumer(), |
| 134 |
/*ShouldOwnClient=*/true); |
| 135 |
} |
| 136 |
|
| 137 |
void TestAST::clear() { |
| 138 |
if (Action) { |
| 139 |
// We notified the preprocessor of EOF already, so detach it first. |
| 140 |
// Sema needs the PP alive until after EndSourceFile() though. |
| 141 |
auto PP = Clang->getPreprocessorPtr(); // Keep PP alive for now. |
| 142 |
Clang->setPreprocessor(nullptr); // Detach so we don't send EOF twice. |
| 143 |
Action->EndSourceFile(); // Destroy ASTContext and Sema. |
| 144 |
// Now Sema is gone, PP can safely be destroyed. |
| 145 |
} |
| 146 |
Action.reset(); |
| 147 |
Clang.reset(); |
| 148 |
Diagnostics.clear(); |
| 149 |
} |
| 150 |
|
| 151 |
TestAST &TestAST::operator=(TestAST &&M) { |
| 152 |
clear(); |
| 153 |
Action = std::move(M.Action); |
| 154 |
Clang = std::move(M.Clang); |
| 155 |
Diagnostics = std::move(M.Diagnostics); |
| 156 |
return *this; |
| 157 |
} |
| 158 |
|
| 159 |
TestAST::TestAST(TestAST &&M) { *this = std::move(M); } |
| 160 |
|
| 161 |
TestAST::~TestAST() { clear(); } |
| 162 |
|
| 163 |
} // end namespace clang |