This is an archive of the discontinued LLVM Phabricator instance.

Differential D76366

[Syntax] Split syntax tests
ClosedPublic

Authored by hlopko on Mar 18 2020, 8:00 AM.

Details

Reviewers
gribozavr2
Commits
rGe9630630ffa2: [Syntax] Split syntax tests
Summary

This patch split Basic test into multple individual tests to allow simpler
filtering and clearer signal into what's broken when it's broken.

Diff Detail

Event Timeline

hlopko created this revision.Mar 18 2020, 8:00 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 18 2020, 8:00 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
hlopko added a parent revision: D76346: [Syntax] Build template declaration nodes.Mar 18 2020, 8:01 AM
gribozavr2 accepted this revision.Mar 18 2020, 8:39 AM
gribozavr2 added inline comments.
clang/unittests/Tooling/Syntax/TreeTest.cpp
643

"using directive"

665

The construct in this test is called a "using declaration".

1420

SP -> Sp

1649

"Complex declarator"?

1685

"Complex declarator"?

This revision is now accepted and ready to land.Mar 18 2020, 8:39 AM
hlopko updated this revision to Diff 251102.Mar 18 2020, 8:47 AM
hlopko marked 5 inline comments as done.

Renaming some tests.

hlopko added a comment.Mar 18 2020, 8:47 AM

Addressed comments.

Harbormaster completed remote builds in B49600: Diff 251085.Mar 18 2020, 9:14 AM
Harbormaster completed remote builds in B49609: Diff 251102.Mar 18 2020, 9:47 AM
hlopko edited parent revisions, added: D76418: [Syntax] Build template declaration nodes; removed: D76346: [Syntax] Build template declaration nodes.Mar 19 2020, 2:08 AM
hlopko added a child revision: D76433: [Syntax] Test both the default and windows target platforms in unittests.Mar 19 2020, 8:21 AM
hlopko updated this revision to Diff 251571.Mar 20 2020, 1:42 AM

Rebase

hlopko removed a parent revision: D76418: [Syntax] Build template declaration nodes.Mar 20 2020, 1:45 AM
Closed by commit rGe9630630ffa2: [Syntax] Split syntax tests (authored by hlopko, committed by gribozavr). · Explain WhyMar 20 2020, 2:08 AM
This revision was automatically updated to reflect the committed changes.
Harbormaster completed remote builds in B49847: Diff 251571.Mar 20 2020, 3:46 AM

Revision Contents

PathSize
clang/
unittests/
Tooling/
Syntax/
733 lines

Diff 251572

clang/unittests/Tooling/Syntax/TreeTest.cpp

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Lines syntax::TranslationUnit *buildTree(llvm::StringRef Code) {
BuildSyntaxTreeAction Recorder(Root, this->Arena); BuildSyntaxTreeAction Recorder(Root, this->Arena);
if (!Compiler.ExecuteAction(Recorder)) { if (!Compiler.ExecuteAction(Recorder)) {
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) {
SCOPED_TRACE(code);
auto *Root = buildTree(code);
std::string Expected = tree.trim().str();
std::string Actual =
std::string(llvm::StringRef(Root->dump(*Arena)).trim());
EXPECT_EQ(Expected, Actual) << "the resulting dump is:\n" << Actual;
}
// Adds a file to the test VFS. // Adds a file to the test VFS.
void addFile(llvm::StringRef Path, llvm::StringRef Contents) { void addFile(llvm::StringRef Path, llvm::StringRef Contents) {
if (!FS->addFile(Path, time_t(), if (!FS->addFile(Path, time_t(),
llvm::MemoryBuffer::getMemBufferCopy(Contents))) { llvm::MemoryBuffer::getMemBufferCopy(Contents))) {
ADD_FAILURE() << "could not add a file to VFS: " << Path; ADD_FAILURE() << "could not add a file to VFS: " << Path;
} }
} }
Show All 27 Lines 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().
std::unique_ptr<syntax::Arena> Arena; std::unique_ptr<syntax::Arena> Arena;
}; };
TEST_F(SyntaxTreeTest, Basic) { TEST_F(SyntaxTreeTest, Simple) {
std::pair</*Input*/ std::string, /*Expected*/ std::string> Cases[] = { expectTreeDumpEqual(
{
R"cpp( R"cpp(
int main() {} int main() {}
void foo() {} void foo() {}
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-main | | |-main
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | `-) | | `-)
| `-CompoundStatement | `-CompoundStatement
| |-{ | |-{
| `-} | `-}
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-foo | |-foo
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
`-} `-}
)txt"}, )txt");
// if. }
{
TEST_F(SyntaxTreeTest, If) {
expectTreeDumpEqual(
R"cpp( R"cpp(
int main() { int main() {
if (true) {} if (true) {}
if (true) {} else if (false) {} if (true) {} else if (false) {}
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-int |-int
|-SimpleDeclarator |-SimpleDeclarator
| |-main | |-main
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
Show All 23 Lines `-CompoundStatement
| |-( | |-(
| |-UnknownExpression | |-UnknownExpression
| | `-false | | `-false
| |-) | |-)
| `-CompoundStatement | `-CompoundStatement
| |-{ | |-{
| `-} | `-}
`-} `-}
)txt"}, )txt");
// for. }
{R"cpp(
TEST_F(SyntaxTreeTest, For) {
expectTreeDumpEqual(
R"cpp(
void test() { void test() {
for (;;) {} for (;;) {}
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-ForStatement |-ForStatement
| |-for | |-for
| |-( | |-(
| |-; | |-;
| |-; | |-;
| |-) | |-)
| `-CompoundStatement | `-CompoundStatement
| |-{ | |-{
| `-} | `-}
`-} `-}
)txt"}, )txt");
// declaration statement. }
{"void test() { int a = 10; }",
TEST_F(SyntaxTreeTest, RangeBasedFor) {
expectTreeDumpEqual(
R"cpp(
void test() {
int a[3];
for (int x : a) ;
}
)cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-DeclarationStatement |-DeclarationStatement
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-int | | |-int
| | `-SimpleDeclarator | | `-SimpleDeclarator
| | |-a | | |-a
| | |-= | | `-ArraySubscript
| | `-UnknownExpression | | |-[
| | `-10 | | |-UnknownExpression
| | | `-3
| | `-]
| `-;
|-RangeBasedForStatement
| |-for
| |-(
| |-SimpleDeclaration
| | |-int
| | |-SimpleDeclarator
| | | `-x
| | `-:
| |-UnknownExpression
| | `-a
| |-)
| `-EmptyStatement
| `-; | `-;
`-} `-}
)txt"}, )txt");
{"void test() { ; }", R"txt( }
TEST_F(SyntaxTreeTest, DeclarationStatement) {
expectTreeDumpEqual("void test() { int a = 10; }",
R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-EmptyStatement |-DeclarationStatement
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | |-a
| | |-=
| | `-UnknownExpression
| | `-10
| `-; | `-;
`-} `-}
)txt"}, )txt");
// switch, case and default. }
{R"cpp(
TEST_F(SyntaxTreeTest, Switch) {
expectTreeDumpEqual(
R"cpp(
void test() { void test() {
switch (true) { switch (true) {
case 0: case 0:
default:; default:;
} }
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
Show All 14 Lines `-CompoundStatement
| | |-: | | |-:
| | `-DefaultStatement | | `-DefaultStatement
| | |-default | | |-default
| | |-: | | |-:
| | `-EmptyStatement | | `-EmptyStatement
| | `-; | | `-;
| `-} | `-}
`-} `-}
)txt"}, )txt");
// while. }
{R"cpp(
TEST_F(SyntaxTreeTest, While) {
expectTreeDumpEqual(
R"cpp(
void test() { void test() {
while (true) { continue; break; } while (true) { continue; break; }
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
Show All 10 Lines `-CompoundStatement
| |-ContinueStatement | |-ContinueStatement
| | |-continue | | |-continue
| | `-; | | `-;
| |-BreakStatement | |-BreakStatement
| | |-break | | |-break
| | `-; | | `-;
| `-} | `-}
`-} `-}
)txt"}, )txt");
// return.
{R"cpp(
int test() { return 1; }
)cpp",
R"txt(
*: TranslationUnit
`-SimpleDeclaration
|-int
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ReturnStatement
| |-return
| |-UnknownExpression
| | `-1
| `-;
`-}
)txt"},
// Range-based for.
{R"cpp(
void test() {
int a[3];
for (int x : a) ;
} }
)cpp",
R"txt( TEST_F(SyntaxTreeTest, UnhandledStatement) {
*: TranslationUnit
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-DeclarationStatement
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | |-a
| | `-ArraySubscript
| | |-[
| | |-UnknownExpression
| | | `-3
| | `-]
| `-;
|-RangeBasedForStatement
| |-for
| |-(
| |-SimpleDeclaration
| | |-int
| | |-SimpleDeclarator
| | | `-x
| | `-:
| |-UnknownExpression
| | `-a
| |-)
| `-EmptyStatement
| `-;
`-}
)txt"},
// 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.
{"void main() { foo: return 100; }", R"txt( expectTreeDumpEqual("void main() { foo: return 100; }",
R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-main | |-main
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-UnknownStatement |-UnknownStatement
| |-foo | |-foo
| |-: | |-:
| `-ReturnStatement | `-ReturnStatement
| |-return | |-return
| |-UnknownExpression | |-UnknownExpression
| | `-100 | | `-100
| `-; | `-;
`-} `-}
)txt"}, )txt");
}
TEST_F(SyntaxTreeTest, Expressions) {
// expressions should be wrapped in 'ExpressionStatement' when they appear // expressions should be wrapped in 'ExpressionStatement' when they appear
// in a statement position. // in a statement position.
{R"cpp( expectTreeDumpEqual(
R"cpp(
void test() { void test() {
test(); test();
if (true) test(); else test(); if (true) test(); else test();
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
Show All 20 Lines `-CompoundStatement
| |-else | |-else
| `-ExpressionStatement | `-ExpressionStatement
| |-UnknownExpression | |-UnknownExpression
| | |-test | | |-test
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
`-} `-}
)txt"}, )txt");
// Multiple declarators group into a single SimpleDeclaration. }
{R"cpp(
TEST_F(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
expectTreeDumpEqual(
R"cpp(
int *a, b; int *a, b;
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-int |-int
|-SimpleDeclarator |-SimpleDeclarator
| |-* | |-*
| `-a | `-a
|-, |-,
|-SimpleDeclarator |-SimpleDeclarator
| `-b | `-b
`-; `-;
)txt"}, )txt");
{R"cpp( expectTreeDumpEqual(
R"cpp(
typedef int *a, b; typedef int *a, b;
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-typedef |-typedef
|-int |-int
|-SimpleDeclarator |-SimpleDeclarator
| |-* | |-*
| `-a | `-a
|-, |-,
|-SimpleDeclarator |-SimpleDeclarator
| `-b | `-b
`-; `-;
)txt"}, )txt");
// Multiple declarators inside a statement. }
{R"cpp(
TEST_F(SyntaxTreeTest, MultipleDeclaratorsInsideStatement) {
expectTreeDumpEqual(
R"cpp(
void foo() { void foo() {
int *a, b; int *a, b;
typedef int *ta, tb; typedef int *ta, tb;
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-foo | |-foo
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
Show All 16 Lines `-CompoundStatement
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-* | | | |-*
| | | `-ta | | | `-ta
| | |-, | | |-,
| | `-SimpleDeclarator | | `-SimpleDeclarator
| | `-tb | | `-tb
| `-; | `-;
`-} `-}
)txt"}, )txt");
{R"cpp( }
TEST_F(SyntaxTreeTest, Namespaces) {
expectTreeDumpEqual(
R"cpp(
namespace a { namespace b {} } namespace a { namespace b {} }
namespace a::b {} namespace a::b {}
namespace {} namespace {}
namespace foo = a; namespace foo = a;
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-NamespaceDefinition |-NamespaceDefinition
| |-namespace | |-namespace
| |-a | |-a
| |-{ | |-{
| |-NamespaceDefinition | |-NamespaceDefinition
| | |-namespace | | |-namespace
| | |-b | | |-b
Show All 12 Lines
| |-{ | |-{
| `-} | `-}
`-NamespaceAliasDefinition `-NamespaceAliasDefinition
|-namespace |-namespace
|-foo |-foo
|-= |-=
|-a |-a
`-; `-;
)txt"}, )txt");
}
TEST_F(SyntaxTreeTest, UsingDirective) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

"using directive"

gribozavr2: "using directive"
expectTreeDumpEqual(
R"cpp(
namespace ns {}
using namespace ::ns;
)cpp",
R"txt(
*: TranslationUnit
|-NamespaceDefinition
| |-namespace
| |-ns
| |-{
| `-}
`-UsingNamespaceDirective
|-using
|-namespace
|-::
|-ns
`-;
)txt");
}
TEST_F(SyntaxTreeTest, UsingDeclaration) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

The construct in this test is called a "using declaration".

gribozavr2: The construct in this test is called a "using declaration".
expectTreeDumpEqual(
R"cpp(
namespace ns { int a; }
using ns::a;
)cpp",
R"txt(
*: TranslationUnit
|-NamespaceDefinition
| |-namespace
| |-ns
| |-{
| |-SimpleDeclaration
| | |-int
| | |-SimpleDeclarator
| | | `-a
| | `-;
| `-}
`-UsingDeclaration
|-using
|-ns
|-::
|-a
`-;
)txt");
}
TEST_F(SyntaxTreeTest, FreeStandingClasses) {
// Free-standing classes, must live inside a SimpleDeclaration. // Free-standing classes, must live inside a SimpleDeclaration.
{R"cpp( expectTreeDumpEqual(
R"cpp(
sturct X; sturct 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 | |-sturct
| |-X | |-X
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
| |-struct | |-struct
| |-X | |-X
Show All 19 Lines
`-SimpleDeclaration `-SimpleDeclaration
|-struct |-struct
|-{ |-{
|-} |-}
|-SimpleDeclarator |-SimpleDeclarator
| |-* | |-*
| `-a1 | `-a1
`-; `-;
)txt"}, )txt");
{R"cpp( }
TEST_F(SyntaxTreeTest, Templates) {
expectTreeDumpEqual(
R"cpp(
template <class T> struct cls {}; template <class T> struct cls {};
template <class T> int var = 10; template <class T> int var = 10;
template <class T> int fun() {} template <class T> int fun() {}
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-TemplateDeclaration |-TemplateDeclaration
| |-template | |-template
| |-< | |-<
| |-UnknownDeclaration | |-UnknownDeclaration
| | |-class | | |-class
| | `-T | | `-T
| |-> | |->
Show All 30 Lines `-SimpleDeclaration
|-SimpleDeclarator |-SimpleDeclarator
| |-fun | |-fun
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
`-} `-}
)txt"}, )txt");
{R"cpp( }
TEST_F(SyntaxTreeTest, NestedTemplates) {
expectTreeDumpEqual(
R"cpp(
template <class T> template <class T>
struct X { struct X {
template <class U> template <class U>
U foo(); U foo();
}; };
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-TemplateDeclaration `-TemplateDeclaration
|-template |-template
|-< |-<
|-UnknownDeclaration |-UnknownDeclaration
| |-class | |-class
| `-T | `-T
|-> |->
Show All 13 Lines `-SimpleDeclaration
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-foo | | |-foo
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
|-} |-}
`-; `-;
)txt"}, )txt");
{R"cpp( }
template <class T> struct X {};
template <class T> struct X<T*> {};
template <> struct X<int> {};
template struct X<double>; TEST_F(SyntaxTreeTest, Templates2) {
extern template struct X<float>; expectTreeDumpEqual(
)cpp", R"cpp(
R"txt(
*: TranslationUnit
|-TemplateDeclaration
| |-template
| |-<
| |-UnknownDeclaration
| | |-class
| | `-T
| |->
| `-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-}
| `-;
|-TemplateDeclaration
| |-template
| |-<
| |-UnknownDeclaration
| | |-class
| | `-T
| |->
| `-SimpleDeclaration
| |-struct
| |-X
| |-<
| |-T
| |-*
| |->
| |-{
| |-}
| `-;
|-TemplateDeclaration
| |-template
| |-<
| |->
| `-SimpleDeclaration
| |-struct
| |-X
| |-<
| |-int
| |->
| |-{
| |-}
| `-;
|-ExplicitTemplateInstantiation
| |-template
| `-SimpleDeclaration
| |-struct
| |-X
| |-<
| |-double
| |->
| `-;
`-ExplicitTemplateInstantiation
|-extern
|-template
`-SimpleDeclaration
|-struct
|-X
|-<
|-float
|->
`-;
)txt"},
{R"cpp(
template <class T> struct X { struct Y; }; template <class T> struct X { struct Y; };
template <class T> struct X<T>::Y {}; template <class T> struct X<T>::Y {};
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-TemplateDeclaration |-TemplateDeclaration
| |-template | |-template
| |-< | |-<
| |-UnknownDeclaration | |-UnknownDeclaration
| | |-class | | |-class
| | `-T | | `-T
| |-> | |->
Show All 20 Lines `-SimpleDeclaration
|-< |-<
|-T |-T
|-> |->
|-:: |-::
|-Y |-Y
|-{ |-{
|-} |-}
`-; `-;
)txt"}, )txt");
{R"cpp( }
namespace ns {}
using namespace ::ns; TEST_F(SyntaxTreeTest, TemplatesUsingUsing) {
)cpp", expectTreeDumpEqual(
R"txt( R"cpp(
*: TranslationUnit
|-NamespaceDefinition
| |-namespace
| |-ns
| |-{
| `-}
`-UsingNamespaceDirective
|-using
|-namespace
|-::
|-ns
`-;
)txt"},
{R"cpp(
namespace ns { int a; }
using ns::a;
)cpp",
R"txt(
*: TranslationUnit
|-NamespaceDefinition
| |-namespace
| |-ns
| |-{
| |-SimpleDeclaration
| | |-int
| | |-SimpleDeclarator
| | | `-a
| | `-;
| `-}
`-UsingDeclaration
|-using
|-ns
|-::
|-a
`-;
)txt"},
{R"cpp(
template <class T> struct X { template <class T> struct X {
using T::foo; using T::foo;
using typename T::bar; using typename T::bar;
}; };
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-TemplateDeclaration `-TemplateDeclaration
|-template |-template
|-< |-<
|-UnknownDeclaration |-UnknownDeclaration
| |-class | |-class
| `-T | `-T
|-> |->
Show All 11 Lines `-SimpleDeclaration
| |-using | |-using
| |-typename | |-typename
| |-T | |-T
| |-:: | |-::
| |-bar | |-bar
| `-; | `-;
|-} |-}
`-; `-;
)txt"}, )txt");
{R"cpp( }
TEST_F(SyntaxTreeTest, ExplicitTemplateInstantations) {
expectTreeDumpEqual(
R"cpp(
template <class T> struct X {};
template <class T> struct X<T*> {};
template <> struct X<int> {};
template struct X<double>;
extern template struct X<float>;
)cpp",
R"txt(
*: TranslationUnit
|-TemplateDeclaration
| |-template
| |-<
| |-UnknownDeclaration
| | |-class
| | `-T
| |->
| `-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-}
| `-;
|-TemplateDeclaration
| |-template
| |-<
| |-UnknownDeclaration
| | |-class
| | `-T
| |->
| `-SimpleDeclaration
| |-struct
| |-X
| |-<
| |-T
| |-*
| |->
| |-{
| |-}
| `-;
|-TemplateDeclaration
| |-template
| |-<
| |->
| `-SimpleDeclaration
| |-struct
| |-X
| |-<
| |-int
| |->
| |-{
| |-}
| `-;
|-ExplicitTemplateInstantiation
| |-template
| `-SimpleDeclaration
| |-struct
| |-X
| |-<
| |-double
| |->
| `-;
`-ExplicitTemplateInstantiation
|-extern
|-template
`-SimpleDeclaration
|-struct
|-X
|-<
|-float
|->
`-;
)txt");
}
TEST_F(SyntaxTreeTest, UsingType) {
expectTreeDumpEqual(
R"cpp(
using type = int; using type = int;
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-TypeAliasDeclaration `-TypeAliasDeclaration
|-using |-using
|-type |-type
|-= |-=
|-int |-int
`-; `-;
)txt"}, )txt");
{R"cpp( }
TEST_F(SyntaxTreeTest, EmptyDeclaration) {
expectTreeDumpEqual(
R"cpp(
; ;
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-EmptyDeclaration `-EmptyDeclaration
`-; `-;
)txt"}, )txt");
{R"cpp( }
TEST_F(SyntaxTreeTest, StaticAssert) {
expectTreeDumpEqual(
R"cpp(
static_assert(true, "message"); static_assert(true, "message");
static_assert(true); static_assert(true);
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-StaticAssertDeclaration |-StaticAssertDeclaration
| |-static_assert | |-static_assert
| |-( | |-(
| |-UnknownExpression | |-UnknownExpression
| | `-true | | `-true
| |-, | |-,
| |-UnknownExpression | |-UnknownExpression
| | `-"message" | | `-"message"
| |-) | |-)
| `-; | `-;
`-StaticAssertDeclaration `-StaticAssertDeclaration
|-static_assert |-static_assert
|-( |-(
|-UnknownExpression |-UnknownExpression
| `-true | `-true
|-) |-)
`-; `-;
)txt"}, )txt");
{R"cpp( }
TEST_F(SyntaxTreeTest, ExternC) {
expectTreeDumpEqual(
R"cpp(
extern "C" int a; extern "C" int a;
extern "C" { int b; int c; } extern "C" { int b; int c; }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-LinkageSpecificationDeclaration |-LinkageSpecificationDeclaration
| |-extern | |-extern
| |-"C" | |-"C"
| `-SimpleDeclaration | `-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | `-a | | `-a
| `-; | `-;
`-LinkageSpecificationDeclaration `-LinkageSpecificationDeclaration
|-extern |-extern
|-"C" |-"C"
|-{ |-{
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | `-b | | `-b
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | `-c | | `-c
| `-; | `-;
`-} `-}
)txt"}, )txt");
}
TEST_F(SyntaxTreeTest, NonModifiableNodes) {
// Some nodes are non-modifiable, they are marked with 'I:'. // Some nodes are non-modifiable, they are marked with 'I:'.
{R"cpp( expectTreeDumpEqual(
R"cpp(
#define HALF_IF if (1+ #define HALF_IF if (1+
#define HALF_IF_2 1) {} #define HALF_IF_2 1) {}
void test() { void test() {
HALF_IF HALF_IF_2 else {} HALF_IF HALF_IF_2 else {}
})cpp", })cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
Show All 10 Lines `-CompoundStatement
| |-I: CompoundStatement | |-I: CompoundStatement
| | |-I: { | | |-I: {
| | `-I: } | | `-I: }
| |-else | |-else
| `-CompoundStatement | `-CompoundStatement
| |-{ | |-{
| `-} | `-}
`-} `-}
)txt"}, )txt");
// All nodes can be mutated. // All nodes can be mutated.
{R"cpp( expectTreeDumpEqual(
R"cpp(
#define OPEN { #define OPEN {
#define CLOSE } #define CLOSE }
void test() { void test() {
OPEN OPEN
1; 1;
CLOSE CLOSE
OPEN OPEN
2; 2;
} }
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
Show All 9 Lines `-CompoundStatement
|-CompoundStatement |-CompoundStatement
| |-{ | |-{
| |-ExpressionStatement | |-ExpressionStatement
| | |-UnknownExpression | | |-UnknownExpression
| | | `-2 | | | `-2
| | `-; | | `-;
| `-} | `-}
`-} `-}
)txt"}, )txt");
// Array subscripts in declarators. }
{R"cpp(
TEST_F(SyntaxTreeTest, ArraySubscriptsInDeclarators) {
expectTreeDumpEqual(
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
| | |-[ | | |-[
| | |-UnknownExpression | | |-UnknownExpression
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines`-SimpleDeclaration
| | `-ArraySubscript | | `-ArraySubscript
| | |-[ | | |-[
| | |-static | | |-static
| | |-UnknownExpression | | |-UnknownExpression
| | | `-10 | | | `-10
| | `-] | | `-]
| `-) | `-)
`-; `-;
)txt"}, )txt");
// Parameter lists in declarators. }
{R"cpp(
TEST_F(SyntaxTreeTest, ParameterListsInDeclarators) {
expectTreeDumpEqual(
R"cpp(
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, const int a,
volatile int b, volatile int b,
const volatile int c, const volatile int c,
int* d, int* d,
int& e, int& e,
int&& f int&& f
); );
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-a | | |-a
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-) | | |-)
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines`-SimpleDeclaration
| |-, | |-,
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-int | | |-int
| | `-SimpleDeclarator | | `-SimpleDeclarator
| | |-&& | | |-&&
| | `-f | | `-f
| `-) | `-)
`-; `-;
)txt"}, )txt");
// Trailing const qualifier. }
{R"cpp(
TEST_F(SyntaxTreeTest, TrailingConst) {
expectTreeDumpEqual(
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");
// Trailing return type in parameter lists. }
{R"cpp(
TEST_F(SyntaxTreeTest, TrailingReturn) {
expectTreeDumpEqual(
R"cpp(
auto foo() -> int; auto foo() -> int;
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-auto |-auto
|-SimpleDeclarator |-SimpleDeclarator
| |-foo | |-foo
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-) | |-)
| `-TrailingReturnType | `-TrailingReturnType
| |--> | |-->
| `-int | `-int
`-; `-;
)txt"}, )txt");
// Exception specification in parameter lists. }
{R"cpp(
TEST_F(SyntaxTreeTest, ExceptionSpecification) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

SP -> Sp

gribozavr2: SP -> Sp
expectTreeDumpEqual(
R"cpp(
int a() noexcept; int a() noexcept;
int b() noexcept(true); int b() noexcept(true);
int c() throw(); int c() throw();
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-a | | |-a
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-) | | |-)
Show All 18 Lines`-SimpleDeclaration
| |-c | |-c
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-) | |-)
| |-throw | |-throw
| |-( | |-(
| `-) | `-)
`-; `-;
)txt"}, )txt");
// Declarators in parentheses. }
{R"cpp(
TEST_F(SyntaxTreeTest, DeclaratorsInParentheses) {
expectTreeDumpEqual(
R"cpp(
int (a); int (a);
int *(b); int *(b);
int (*c)(int); int (*c)(int);
int *(d)(int); int *(d)(int);
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | `-ParenDeclarator | | `-ParenDeclarator
| | |-( | | |-(
| | |-a | | |-a
| | `-) | | `-)
Show All 30 Lines`-SimpleDeclaration
| | |-d | | |-d
| | `-) | | `-)
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-SimpleDeclaration | |-SimpleDeclaration
| | `-int | | `-int
| `-) | `-)
`-; `-;
)txt"}, )txt");
// CV qualifiers. }
{R"cpp(
TEST_F(SyntaxTreeTest, ConstVolatileQualifiers) {
expectTreeDumpEqual(
R"cpp(
const int west = -1; const int west = -1;
int const east = 1; int const east = 1;
const int const universal = 0; const int const universal = 0;
const int const *const *volatile b; const int const *const *volatile b;
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-const | |-const
| |-int | |-int
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-west | | |-west
| | |-= | | |-=
| | `-UnknownExpression | | `-UnknownExpression
Show All 25 Lines`-SimpleDeclaration
|-const |-const
|-SimpleDeclarator |-SimpleDeclarator
| |-* | |-*
| |-const | |-const
| |-* | |-*
| |-volatile | |-volatile
| `-b | `-b
`-; `-;
)txt"}, )txt");
// Ranges of declarators with trailing return types. }
{R"cpp(
TEST_F(SyntaxTreeTest, RangesOfDeclaratorsWithTrailingReturnTypes) {
expectTreeDumpEqual(
R"cpp(
auto foo() -> auto(*)(int) -> double*; auto foo() -> auto(*)(int) -> double*;
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-auto |-auto
|-SimpleDeclarator |-SimpleDeclarator
| |-foo | |-foo
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-) | |-)
Show All 11 Lines`-SimpleDeclaration
| | `-int | | `-int
| |-) | |-)
| `-TrailingReturnType | `-TrailingReturnType
| |--> | |-->
| |-double | |-double
| `-SimpleDeclarator | `-SimpleDeclarator
| `-* | `-*
`-; `-;
)txt"}, )txt");
// Member pointers. }
{R"cpp(
TEST_F(SyntaxTreeTest, MemberPointers) {
expectTreeDumpEqual(
R"cpp(
struct X {}; struct X {};
int X::* a; int X::* a;
const int X::* b; const int X::* b;
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-struct | |-struct
| |-X | |-X
| |-{ | |-{
| |-} | |-}
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
Show All 10 Lines`-SimpleDeclaration
|-int |-int
|-SimpleDeclarator |-SimpleDeclarator
| |-MemberPointer | |-MemberPointer
| | |-X | | |-X
| | |-:: | | |-::
| | `-* | | `-*
| `-b | `-b
`-; `-;
)txt"}, )txt");
// All-in-one tests. }
{R"cpp(
TEST_F(SyntaxTreeTest, ComplexDeclarator) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

"Complex declarator"?

gribozavr2: "Complex declarator"?
expectTreeDumpEqual(
R"cpp(
void x(char a, short (*b)(int)); void x(char a, short (*b)(int));
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-x | |-x
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-SimpleDeclaration | |-SimpleDeclaration
Show All 11 Lines`-SimpleDeclaration
| | | `-) | | | `-)
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-SimpleDeclaration | | |-SimpleDeclaration
| | | `-int | | | `-int
| | `-) | | `-)
| `-) | `-)
`-; `-;
)txt"}, )txt");
{R"cpp( }
TEST_F(SyntaxTreeTest, ComplexDeclarator2) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

"Complex declarator"?

gribozavr2: "Complex declarator"?
expectTreeDumpEqual(
R"cpp(
void x(char a, short (*b)(int), long (**c)(long long)); void x(char a, short (*b)(int), long (**c)(long long));
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-x | |-x
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-SimpleDeclaration | |-SimpleDeclaration
Show All 27 Lines`-SimpleDeclaration
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-SimpleDeclaration | | |-SimpleDeclaration
| | | |-long | | | |-long
| | | `-long | | | `-long
| | `-) | | `-)
| `-) | `-)
`-; `-;
)txt"}, )txt");
};
for (const auto &T : Cases) {
SCOPED_TRACE(T.first);
auto *Root = buildTree(T.first);
std::string Expected = llvm::StringRef(T.second).trim().str();
std::string Actual =
std::string(llvm::StringRef(Root->dump(*Arena)).trim());
EXPECT_EQ(Expected, Actual) << "the resulting dump is:\n" << Actual;
}
} }
TEST_F(SyntaxTreeTest, Mutations) { TEST_F(SyntaxTreeTest, Mutations) {
using Transformation = std::function<void( using Transformation = std::function<void(
const llvm::Annotations & /*Input*/, syntax::TranslationUnit * /*Root*/)>; const llvm::Annotations & /*Input*/, syntax::TranslationUnit * /*Root*/)>;
auto CheckTransformation = [this](std::string Input, std::string Expected, auto CheckTransformation = [this](std::string Input, std::string Expected,
Transformation Transform) -> void { Transformation Transform) -> void {
llvm::Annotations Source(Input); llvm::Annotations Source(Input);
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines