This is an archive of the discontinued LLVM Phabricator instance.

Differential D80731

Improve test infrastructure in SyntaxTree
ClosedPublic

Authored by eduucaldas on May 28 2020, 8:59 AM.

Details

Reviewers
gribozavr2
Commits
rGeca41919d28b: Improve test infrastructure in SyntaxTree
Summary
  • Test if the code sourcing the SyntaxTree compiles
  • Output compiler errors and warnings to err
  • Fix tests with code that did not compile

Diff Detail

Event Timeline

eduucaldas created this revision.May 28 2020, 8:59 AM
Herald added a project: Restricted Project. · View Herald TranscriptMay 28 2020, 8:59 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
eduucaldas added a reviewer: gribozavr2.May 28 2020, 9:01 AM
gribozavr2 accepted this revision.May 28 2020, 9:23 AM
This revision is now accepted and ready to land.May 28 2020, 9:23 AM
Harbormaster completed remote builds in B58241: Diff 266898.May 28 2020, 12:06 PM
Closed by commit rGeca41919d28b: Improve test infrastructure in SyntaxTree (authored by eduucaldas, committed by gribozavr). · Explain WhyMay 28 2020, 12:40 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
clang/
unittests/
Tooling/
Syntax/
311 lines

Diff 266993

clang/unittests/Tooling/Syntax/TreeTest.cpp

Show All 9 Lines
#include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTConsumer.h"
#include "clang/AST/Decl.h" #include "clang/AST/Decl.h"
#include "clang/AST/Stmt.h" #include "clang/AST/Stmt.h"
#include "clang/Basic/LLVM.h" #include "clang/Basic/LLVM.h"
#include "clang/Basic/TokenKinds.h" #include "clang/Basic/TokenKinds.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/CompilerInvocation.h" #include "clang/Frontend/CompilerInvocation.h"
#include "clang/Frontend/FrontendAction.h" #include "clang/Frontend/FrontendAction.h"
#include "clang/Frontend/TextDiagnosticPrinter.h"
#include "clang/Lex/PreprocessorOptions.h" #include "clang/Lex/PreprocessorOptions.h"
#include "clang/Tooling/Core/Replacement.h" #include "clang/Tooling/Core/Replacement.h"
#include "clang/Tooling/Syntax/BuildTree.h" #include "clang/Tooling/Syntax/BuildTree.h"
#include "clang/Tooling/Syntax/Mutations.h" #include "clang/Tooling/Syntax/Mutations.h"
#include "clang/Tooling/Syntax/Nodes.h" #include "clang/Tooling/Syntax/Nodes.h"
#include "clang/Tooling/Syntax/Tokens.h" #include "clang/Tooling/Syntax/Tokens.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines buildTree(llvm::StringRef Code,
private: private:
syntax::TranslationUnit *&Root; syntax::TranslationUnit *&Root;
std::unique_ptr<syntax::Arena> &Arena; std::unique_ptr<syntax::Arena> &Arena;
}; };
constexpr const char *FileName = "./input.cpp"; constexpr const char *FileName = "./input.cpp";
FS->addFile(FileName, time_t(), llvm::MemoryBuffer::getMemBufferCopy("")); FS->addFile(FileName, time_t(), llvm::MemoryBuffer::getMemBufferCopy(""));
if (!Diags->getClient()) if (!Diags->getClient())
Diags->setClient(new IgnoringDiagConsumer); Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), DiagOpts.get()));
Diags->setSeverityForGroup(diag::Flavor::WarningOrError, "unused-value",
diag::Severity::Ignored, SourceLocation());
// Prepare to run a compiler. // Prepare to run a compiler.
std::vector<const char *> Args = { std::vector<const char *> Args = {
"syntax-test", "-target", Target.c_str(), "syntax-test", "-target", Target.c_str(),
FileName, "-fsyntax-only", "-std=c++17", FileName, "-fsyntax-only", "-std=c++17",
}; };
Invocation = createInvocationFromCommandLine(Args, Diags, FS); Invocation = createInvocationFromCommandLine(Args, Diags, FS);
assert(Invocation); assert(Invocation);
Invocation->getFrontendOpts().DisableFree = false; Invocation->getFrontendOpts().DisableFree = false;
Invocation->getPreprocessorOpts().addRemappedFile( Invocation->getPreprocessorOpts().addRemappedFile(
FileName, llvm::MemoryBuffer::getMemBufferCopy(Code).release()); FileName, llvm::MemoryBuffer::getMemBufferCopy(Code).release());
CompilerInstance Compiler; CompilerInstance Compiler;
Compiler.setInvocation(Invocation); Compiler.setInvocation(Invocation);
Compiler.setDiagnostics(Diags.get()); Compiler.setDiagnostics(Diags.get());
Compiler.setFileManager(FileMgr.get()); Compiler.setFileManager(FileMgr.get());
Compiler.setSourceManager(SourceMgr.get()); Compiler.setSourceManager(SourceMgr.get());
syntax::TranslationUnit *Root = nullptr; syntax::TranslationUnit *Root = nullptr;
BuildSyntaxTreeAction Recorder(Root, this->Arena); BuildSyntaxTreeAction Recorder(Root, this->Arena);
if (!Compiler.ExecuteAction(Recorder)) {
// Action could not be executed but the frontend didn't identify any errors
// in the code ==> problem in setting up the action.
if (!Compiler.ExecuteAction(Recorder) &&
Diags->getClient()->getNumErrors() == 0) {
ADD_FAILURE() << "failed to run the frontend"; ADD_FAILURE() << "failed to run the frontend";
std::abort(); std::abort();
} }
return Root; return Root;
} }
void expectTreeDumpEqual(StringRef Code, StringRef Tree, void expectTreeDumpEqual(StringRef Code, StringRef Tree,
bool RunWithDelayedTemplateParsing = true) { bool RunWithDelayedTemplateParsing = true) {
Show All 9 Lines void expectTreeDumpEqual(StringRef Code, StringRef Tree,
// early. // early.
for (const std::string Target : for (const std::string Target :
{"x86_64-pc-linux-gnu", "x86_64-pc-win32-msvc"}) { {"x86_64-pc-linux-gnu", "x86_64-pc-win32-msvc"}) {
if (!RunWithDelayedTemplateParsing && if (!RunWithDelayedTemplateParsing &&
Target == "x86_64-pc-win32-msvc") { Target == "x86_64-pc-win32-msvc") {
continue; continue;
} }
auto *Root = buildTree(Code, Target); auto *Root = buildTree(Code, Target);
EXPECT_EQ(Diags->getClient()->getNumErrors(), 0u)
<< "Source file has syntax errors, they were printed to the test log";
std::string Actual = std::string(StringRef(Root->dump(*Arena)).trim()); std::string Actual = std::string(StringRef(Root->dump(*Arena)).trim());
EXPECT_EQ(Expected, Actual) EXPECT_EQ(Expected, Actual)
<< "for target " << Target << " the resulting dump is:\n" << "for target " << Target << " the resulting dump is:\n"
<< Actual; << Actual;
} }
} }
// Adds a file to the test VFS. // Adds a file to the test VFS.
Show All 21 Lines syntax::Node *nodeByRange(llvm::Annotations::Range R, syntax::Node *Root) {
for (auto *C = T->firstChild(); C != nullptr; C = C->nextSibling()) { for (auto *C = T->firstChild(); C != nullptr; C = C->nextSibling()) {
if (auto *Result = nodeByRange(R, C)) if (auto *Result = nodeByRange(R, C))
return Result; return Result;
} }
return nullptr; return nullptr;
} }
// Data fields. // Data fields.
llvm::IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts =
new DiagnosticOptions();
llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags = llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
new DiagnosticsEngine(new DiagnosticIDs, new DiagnosticOptions); new DiagnosticsEngine(new DiagnosticIDs, DiagOpts.get());
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS =
new llvm::vfs::InMemoryFileSystem; new llvm::vfs::InMemoryFileSystem;
llvm::IntrusiveRefCntPtr<FileManager> FileMgr = llvm::IntrusiveRefCntPtr<FileManager> FileMgr =
new FileManager(FileSystemOptions(), FS); new FileManager(FileSystemOptions(), FS);
llvm::IntrusiveRefCntPtr<SourceManager> SourceMgr = llvm::IntrusiveRefCntPtr<SourceManager> SourceMgr =
new SourceManager(*Diags, *FileMgr); new SourceManager(*Diags, *FileMgr);
std::shared_ptr<CompilerInvocation> Invocation; std::shared_ptr<CompilerInvocation> Invocation;
// Set after calling buildTree(). // Set after calling buildTree().
▲ Show 20 Lines • Show All 319 Lines • ▼ Show 20 Lines `-CompoundStatement
`-} `-}
)txt"); )txt");
} }
TEST_F(SyntaxTreeTest, UnhandledStatement) { TEST_F(SyntaxTreeTest, UnhandledStatement) {
// Unhandled statements should end up as 'unknown statement'. // Unhandled statements should end up as 'unknown statement'.
// This example uses a 'label statement', which does not yet have a syntax // This example uses a 'label statement', which does not yet have a syntax
// counterpart. // counterpart.
expectTreeDumpEqual("void main() { foo: return 100; }", expectTreeDumpEqual("int main() { foo: return 100; }",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-int
|-SimpleDeclarator |-SimpleDeclarator
| |-main | |-main
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-UnknownStatement |-UnknownStatement
▲ Show 20 Lines • Show All 628 Lines • ▼ Show 20 Lines`-UsingDeclaration
`-; `-;
)txt"); )txt");
} }
TEST_F(SyntaxTreeTest, FreeStandingClasses) { TEST_F(SyntaxTreeTest, FreeStandingClasses) {
// Free-standing classes, must live inside a SimpleDeclaration. // Free-standing classes, must live inside a SimpleDeclaration.
expectTreeDumpEqual( expectTreeDumpEqual(
R"cpp( R"cpp(
sturct X; struct X;
struct X {}; struct X {};
struct Y *y1; struct Y *y1;
struct Y {} *y2; struct Y {} *y2;
struct {} *a1; struct {} *a1;
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-sturct | |-struct
| |-X | |-X
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
| |-struct | |-struct
| |-X | |-X
| |-{ | |-{
| |-} | |-}
| `-; | `-;
▲ Show 20 Lines • Show All 466 Lines • ▼ Show 20 Lines
} }
TEST_F(SyntaxTreeTest, ArraySubscriptsInDeclarators) { TEST_F(SyntaxTreeTest, ArraySubscriptsInDeclarators) {
expectTreeDumpEqual( expectTreeDumpEqual(
R"cpp( R"cpp(
int a[10]; int a[10];
int b[1][2][3]; int b[1][2][3];
int c[] = {1,2,3}; int c[] = {1,2,3};
void f(int xs[static 10]); // void f(int xs[static 10]);
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-a | | |-a
| | `-ArraySubscript | | `-ArraySubscript
Show All 17 Lines
| | | | `-2 | | | | `-2
| | | `-] | | | `-]
| | `-ArraySubscript | | `-ArraySubscript
| | |-[ | | |-[
| | |-UnknownExpression | | |-UnknownExpression
| | | `-3 | | | `-3
| | `-] | | `-]
| `-; | `-;
|-SimpleDeclaration
| |-int
| |-SimpleDeclarator
| | |-c
| | |-ArraySubscript
| | | |-[
| | | `-]
| | |-=
| | `-UnknownExpression
| | `-UnknownExpression
| | |-{
| | |-UnknownExpression
| | | `-1
| | |-,
| | |-UnknownExpression
| | | `-2
| | |-,
| | |-UnknownExpression
| | | `-3
| | `-}
| `-;
`-SimpleDeclaration `-SimpleDeclaration
|-void |-int
|-SimpleDeclarator |-SimpleDeclarator
| |-f | |-c
| `-ParametersAndQualifiers | |-ArraySubscript
| |-(
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | |-xs
| | `-ArraySubscript
| | |-[ | | |-[
| | |-static
| | |-UnknownExpression
| | | `-10
| | `-] | | `-]
| `-) | |-=
`-; | `-UnknownExpression
)txt"); | `-UnknownExpression
| |-{
| |-UnknownExpression
| | `-1
| |-,
| |-UnknownExpression
| | `-2
| |-,
| |-UnknownExpression
| | `-3
| `-}
`-; )txt");
} }
TEST_F(SyntaxTreeTest, ParameterListsInDeclarators) { TEST_F(SyntaxTreeTest, ParameterListsInDeclarators) {
expectTreeDumpEqual( expectTreeDumpEqual(
R"cpp( R"cpp(
struct Test {
int a() const; int a() const;
int b() volatile; int b() volatile;
int c() &; int c() &;
int d() &&; int d() &&;
int foo(int a, int b); int foo(int a, int b);
int foo( int foo(const int a, volatile int b, const volatile int c, int* d,
const int a, int& e, int&& f);
volatile int b, };
const volatile int c,
int* d,
int& e,
int&& f
);
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration
|-struct
|-Test
|-{
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-a | | |-a
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-) | | |-)
| | `-const | | `-const
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-b | | |-b
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-) | | |-)
| | `-volatile | | `-volatile
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-c | | |-c
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-) | | |-)
| | `-& | | `-&
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-d | | |-d
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-) | | |-)
| | `-&& | | `-&&
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-foo | | |-foo
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-SimpleDeclaration | | |-SimpleDeclaration
| | | |-int | | | |-int
| | | `-SimpleDeclarator | | | `-SimpleDeclarator
| | | `-a | | | `-a
| | |-, | | |-,
| | |-SimpleDeclaration | | |-SimpleDeclaration
| | | |-int | | | |-int
| | | `-SimpleDeclarator | | | `-SimpleDeclarator
| | | `-b | | | `-b
| | `-) | | `-)
| `-; | `-;
`-SimpleDeclaration |-SimpleDeclaration
|-int | |-int
|-SimpleDeclarator | |-SimpleDeclarator
| |-foo | | |-foo
| `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| |-( | | |-(
| |-SimpleDeclaration | | |-SimpleDeclaration
| | |-const | | | |-const
| | |-int | | | |-int
| | `-SimpleDeclarator | | | `-SimpleDeclarator
| | `-a | | | `-a
| |-, | | |-,
| |-SimpleDeclaration | | |-SimpleDeclaration
| | |-volatile | | | |-volatile
| | |-int | | | |-int
| | `-SimpleDeclarator | | | `-SimpleDeclarator
| | `-b | | | `-b
| |-, | | |-,
| |-SimpleDeclaration | | |-SimpleDeclaration
| | |-const | | | |-const
| | |-volatile | | | |-volatile
| | |-int | | | |-int
| | `-SimpleDeclarator | | | `-SimpleDeclarator
| | `-c | | | `-c
| |-, | | |-,
| |-SimpleDeclaration | | |-SimpleDeclaration
| | |-int | | | |-int
| | `-SimpleDeclarator | | | `-SimpleDeclarator
| | |-* | | | |-*
| | `-d | | | `-d
| |-, | | |-,
| |-SimpleDeclaration | | |-SimpleDeclaration
| | |-int | | | |-int
| | `-SimpleDeclarator | | | `-SimpleDeclarator
| | |-& | | | |-&
| | `-e | | | `-e
| |-, | | |-,
| |-SimpleDeclaration | | |-SimpleDeclaration
| | |-int | | | |-int
| | `-SimpleDeclarator | | | `-SimpleDeclarator
| | |-&& | | | |-&&
| | `-f | | | `-f
| `-) | | `-)
| `-;
|-}
`-; `-;
)txt"); )txt");
} }
TEST_F(SyntaxTreeTest, TrailingConst) { TEST_F(SyntaxTreeTest, TrailingConst) {
expectTreeDumpEqual( expectTreeDumpEqual(
R"cpp( R"cpp(
struct X { struct X {
int foo() const; int foo() const;
} };
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-struct |-struct
|-X |-X
|-{ |-{
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-foo | | |-foo
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-) | | |-)
| | `-const | | `-const
| `-; | `-;
`-} |-}
`-;
)txt"); )txt");
} }
TEST_F(SyntaxTreeTest, TrailingReturn) { TEST_F(SyntaxTreeTest, TrailingReturn) {
expectTreeDumpEqual( expectTreeDumpEqual(
R"cpp( R"cpp(
auto foo() -> int; auto foo() -> int;
)cpp", )cpp",
▲ Show 20 Lines • Show All 395 Lines • Show Last 20 Lines