This is an archive of the discontinued LLVM Phabricator instance.

Differential D85962

[SyntaxTree] Create annotations infrastructure and apply it in expression tests.
ClosedPublic

Authored by eduucaldas on Aug 14 2020, 2:58 AM.

Details

Reviewers
gribozavr2
Commits
rGc8c92b54d74c: [SyntaxTree] Use Annotations based tests for expressions
Summary

In this process we also create some other tests, in order to not lose
coverage when focusing on the annotated code.

Diff Detail

Event Timeline

eduucaldas created this revision.Aug 14 2020, 2:58 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 14 2020, 2:58 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
eduucaldas requested review of this revision.Aug 14 2020, 2:58 AM
eduucaldas updated this revision to Diff 285613.

Previous diff had only the last commit

Harbormaster completed remote builds in B68393: Diff 285612.Aug 14 2020, 3:11 AM
Harbormaster completed remote builds in B68395: Diff 285613.Aug 14 2020, 3:28 AM
eduucaldas updated this revision to Diff 285629.Aug 14 2020, 4:59 AM

Move added Declaration tests to an appropriate place

eduucaldas added a reviewer: gribozavr2.Aug 14 2020, 5:03 AM
eduucaldas updated this revision to Diff 285632.Aug 14 2020, 5:28 AM

Add annotations to the last missing tests in expressions.

gribozavr2 added inline comments.Aug 14 2020, 5:32 AM
clang/unittests/Tooling/Syntax/TreeTestBase.cpp
197
199

ASSERT_EQ I think would be better.

200

LLVM style is usually:

unsigned i = 0; ...

206

Could you dump the annotated source code substring to make debugging failing tests easier?

Harbormaster completed remote builds in B68400: Diff 285629.Aug 14 2020, 5:42 AM
Harbormaster completed remote builds in B68403: Diff 285632.Aug 14 2020, 5:56 AM
gribozavr2 accepted this revision.Aug 14 2020, 3:03 PM

Very nice improvement to tests!

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp
783

The name of this test should be about declarations, and this test should be in the section of this file that has to do with declarations.

951

The name of this test should be only about typedefs, and not about user-defined literals. The test should be also in the section of this file that is about declarations (down below).

2492

I think it should be T var, otherwise T is not used (not using T is valid, but rather unusual).

This revision is now accepted and ready to land.Aug 14 2020, 3:03 PM
eduucaldas updated this revision to Diff 286248.Aug 18 2020, 4:36 AM
eduucaldas marked 7 inline comments as done.

Answering comments

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp
477

A test for this part was created below

clang/unittests/Tooling/Syntax/TreeTestBase.cpp
199

ASSERT_EQ is a macro that returns void, so we cannot use it here.

However that brings another question.
Right now we have methods treeDumpEqual* that return AssertionResults and we use them in our tests in the following way: EXPECT_TRUE(treeDumpEqual*...).
It seems to me that we should instead perform any assertion inside treeDumpEqual*, and then just call it directly in the test.

WDYT? I case you agree we can perform this change in another patch.

206

Very good suggestion :) thanks

Harbormaster completed remote builds in B68731: Diff 286248.Aug 18 2020, 4:37 AM
eduucaldas updated this revision to Diff 286251.Aug 18 2020, 4:41 AM

.

Harbormaster completed remote builds in B68734: Diff 286251.Aug 18 2020, 4:42 AM
eduucaldas updated this revision to Diff 286258.Aug 18 2020, 5:32 AM

Fail on non-matching number of tree dumps and annotations

clang/unittests/Tooling/Syntax/TreeTestBase.cpp
199

We need the EXPECT_TRUE at the test site to get information about in which line number we failed

Harbormaster completed remote builds in B68739: Diff 286258.Aug 18 2020, 5:33 AM
eduucaldas updated this revision to Diff 286259.Aug 18 2020, 5:45 AM

Nit

Harbormaster completed remote builds in B68740: Diff 286259.Aug 18 2020, 5:46 AM
This revision was landed with ongoing or failed builds.Aug 18 2020, 6:01 AM
Closed by commit rGc8c92b54d74c: [SyntaxTree] Use Annotations based tests for expressions (authored by eduucaldas). · Explain Why
This revision was automatically updated to reflect the committed changes.
eduucaldas added a commit: rGc8c92b54d74c: [SyntaxTree] Use Annotations based tests for expressions.

Revision Contents

PathSize
clang/
unittests/
Tooling/
Syntax/
3693 lines
14 lines

Diff 286248

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

Show First 20 Lines • Show All 431 Lines • ▼ Show 20 Lines `-CompoundStatement
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedId_Identifier) { TEST_P(SyntaxTreeTest, UnqualifiedId_Identifier) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test(int a) { void test(int a) {
a; [[a]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit IdExpression
`-SimpleDeclaration `-UnqualifiedId
|-void `-a
|-SimpleDeclarator )txt"}));
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | `-a
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-IdExpression
| | `-UnqualifiedId
| | `-a
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedId_OperatorFunctionId) { TEST_P(SyntaxTreeTest, UnqualifiedId_OperatorFunctionId) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
friend X operator+(const X&, const X&); friend X operator+(const X&, const X&);
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

A test for this part was created below

eduucaldas: A test for this part was created below
}; };
void test(X x) { void test(X x) {
operator+(x, x); [[operator+(x, x)]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit UnknownExpression
|-SimpleDeclaration |-IdExpression
| |-struct | `-UnqualifiedId
| |-X | |-operator
| |-{ | `-+
| |-UnknownDeclaration |-(
| | `-SimpleDeclaration |-IdExpression
| | |-friend | `-UnqualifiedId
| | |-X | `-x
| | |-SimpleDeclarator |-,
| | | |-operator |-IdExpression
| | | |-+ | `-UnqualifiedId
| | | `-ParametersAndQualifiers | `-x
| | | |-( `-)
| | | |-SimpleDeclaration )txt"}));
| | | | |-const
| | | | |-X
| | | | `-SimpleDeclarator
| | | | `-&
| | | |-,
| | | |-SimpleDeclaration
| | | | |-const
| | | | |-X
| | | | `-SimpleDeclarator
| | | | `-&
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | |-operator
| | | `-+
| | |-(
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | |-,
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | `-)
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedId_ConversionFunctionId) { TEST_P(SyntaxTreeTest, UnqualifiedId_ConversionFunctionId) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
operator int(); operator int();
}; };
void test(X x) { void test(X x) {
// TODO: Expose `id-expression` from `MemberExpr` // TODO: Expose `id-expression` from `MemberExpr`
x.operator int(); [[x.operator int()]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit UnknownExpression
|-SimpleDeclaration |-UnknownExpression
| |-struct | |-IdExpression
| |-X | | `-UnqualifiedId
| |-{
| |-SimpleDeclaration
| | |-SimpleDeclarator
| | | |-operator
| | | |-int
| | | `-ParametersAndQualifiers
| | | |-(
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x | | `-x
| `-) | |-.
`-CompoundStatement | |-operator
|-{ | `-int
|-ExpressionStatement |-(
| |-UnknownExpression `-)
| | |-UnknownExpression )txt"}));
| | | |-IdExpression
| | | | `-UnqualifiedId
| | | | `-x
| | | |-.
| | | |-operator
| | | `-int
| | |-(
| | `-)
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedId_LiteralOperatorId) { TEST_P(SyntaxTreeTest, UnqualifiedId_LiteralOperatorId) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
unsigned operator "" _w(char); unsigned operator "" _w(char);
void test() { void test() {
operator "" _w('1'); [[operator "" _w('1')]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit UnknownExpression
|-SimpleDeclaration |-IdExpression
| |-unsigned | `-UnqualifiedId
| |-SimpleDeclarator | |-operator
| | |-operator | |-""
| | |-"" | `-_w
| | |-_w |-(
| | `-ParametersAndQualifiers |-CharacterLiteralExpression
| | |-( | `-'1'
| | |-SimpleDeclaration `-)
| | | `-char )txt"}));
| | `-)
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | |-operator
| | | |-""
| | | `-_w
| | |-(
| | |-CharacterLiteralExpression
| | | `-'1'
| | `-)
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedId_Destructor) { TEST_P(SyntaxTreeTest, UnqualifiedId_Destructor) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { }; struct X { };
void test(X x) { void test(X x) {
// TODO: Expose `id-expression` from `MemberExpr` // TODO: Expose `id-expression` from `MemberExpr`
x.~X(); [[x.~X()]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit UnknownExpression
|-SimpleDeclaration |-UnknownExpression
| |-struct | |-IdExpression
| |-X | | `-UnqualifiedId
| |-{
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x | | `-x
| `-) | |-.
`-CompoundStatement | |-~
|-{ | `-X
|-ExpressionStatement |-(
| |-UnknownExpression `-)
| | |-UnknownExpression )txt"}));
| | | |-IdExpression
| | | | `-UnqualifiedId
| | | | `-x
| | | |-.
| | | |-~
| | | `-X
| | |-(
| | `-)
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedId_DecltypeDestructor) { TEST_P(SyntaxTreeTest, UnqualifiedId_DecltypeDestructor) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { }; struct X { };
void test(X x) { void test(X x) {
// TODO: Expose `id-expression` from `MemberExpr` // TODO: Expose `id-expression` from `MemberExpr`
x.~decltype(x)(); [[x.~decltype(x)()]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit UnknownExpression
|-SimpleDeclaration |-UnknownExpression
| |-struct | |-IdExpression
| |-X | | `-UnqualifiedId
| |-{
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x | | `-x
| `-) | |-.
`-CompoundStatement | `-~
|-{ |-decltype
|-ExpressionStatement |-(
| |-UnknownExpression |-x
| | |-UnknownExpression |-)
| | | |-IdExpression |-(
| | | | `-UnqualifiedId `-)
| | | | `-x )txt"}));
| | | |-.
| | | `-~
| | |-decltype
| | |-(
| | |-x
| | |-)
| | |-(
| | `-)
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedId_TemplateId) { TEST_P(SyntaxTreeTest, UnqualifiedId_TemplateId) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
template<typename T> template<typename T>
T f(); T f();
void test() { void test() {
f<int>(); [[f<int>()]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit UnknownExpression
|-TemplateDeclaration |-IdExpression
| |-template | `-UnqualifiedId
| |-f
| |-< | |-<
| |-UnknownDeclaration | |-int
| | |-typename | `->
| | `-T |-(
| |-> `-)
| `-SimpleDeclaration )txt"}));
| |-T
| |-SimpleDeclarator
| | |-f
| | `-ParametersAndQualifiers
| | |-(
| | `-)
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | |-f
| | | |-<
| | | |-int
| | | `->
| | |-(
| | `-)
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, QualifiedId_NamespaceSpecifier) { TEST_P(SyntaxTreeTest, QualifiedId_NamespaceSpecifier) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
namespace n { namespace n {
struct S { }; struct S { };
} }
void test() { void test() {
::n::S s1; [[::n::S s1]];
n::S s2; [[n::S s2]];
} }
)cpp", )cpp",
{R"txt(
SimpleDeclaration
|-NestedNameSpecifier
| |-::
| |-IdentifierNameSpecifier
| | `-n
| `-::
|-S
`-SimpleDeclarator
`-UnknownExpression
`-s1
)txt",
R"txt( R"txt(
*: TranslationUnit SimpleDeclaration
|-NamespaceDefinition |-NestedNameSpecifier
| |-namespace | |-IdentifierNameSpecifier
| |-n | | `-n
| |-{ | `-::
| |-SimpleDeclaration |-S
| | |-struct `-SimpleDeclarator
| | |-S `-UnknownExpression
| | |-{ `-s2
| | |-} )txt"}));
| | `-;
| `-}
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-DeclarationStatement
| |-SimpleDeclaration
| | |-NestedNameSpecifier
| | | |-::
| | | |-IdentifierNameSpecifier
| | | | `-n
| | | `-::
| | |-S
| | `-SimpleDeclarator
| | `-UnknownExpression
| | `-s1
| `-;
|-DeclarationStatement
| |-SimpleDeclaration
| | |-NestedNameSpecifier
| | | |-IdentifierNameSpecifier
| | | | `-n
| | | `-::
| | |-S
| | `-SimpleDeclarator
| | `-UnknownExpression
| | `-s2
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, QualifiedId_TemplateSpecifier) { TEST_P(SyntaxTreeTest, QualifiedId_TemplateSpecifier) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
template<typename T> template<typename T>
struct ST { struct ST {
struct S { }; struct S { };
}; };
void test() { void test() {
::template ST<int>::S s1; [[::template ST<int>::S s1]];
::ST<int>::S s2; [[::ST<int>::S s2]];
} }
)cpp", )cpp",
{R"txt(
SimpleDeclaration
|-NestedNameSpecifier
| |-::
| |-SimpleTemplateNameSpecifier
| | |-template
| | |-ST
| | |-<
| | |-int
| | `->
| `-::
|-S
`-SimpleDeclarator
`-UnknownExpression
`-s1
)txt",
R"txt( R"txt(
*: TranslationUnit SimpleDeclaration
|-TemplateDeclaration |-NestedNameSpecifier
| |-template | |-::
| |-< | |-SimpleTemplateNameSpecifier
| |-UnknownDeclaration | | |-ST
| | |-typename | | |-<
| | `-T | | |-int
| |-> | | `->
| `-SimpleDeclaration | `-::
| |-struct |-S
| |-ST `-SimpleDeclarator
| |-{ `-UnknownExpression
| |-SimpleDeclaration `-s2
| | |-struct )txt"}));
| | |-S
| | |-{
| | |-}
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-DeclarationStatement
| |-SimpleDeclaration
| | |-NestedNameSpecifier
| | | |-::
| | | |-SimpleTemplateNameSpecifier
| | | | |-template
| | | | |-ST
| | | | |-<
| | | | |-int
| | | | `->
| | | `-::
| | |-S
| | `-SimpleDeclarator
| | `-UnknownExpression
| | `-s1
| `-;
|-DeclarationStatement
| |-SimpleDeclaration
| | |-NestedNameSpecifier
| | | |-::
| | | |-SimpleTemplateNameSpecifier
| | | | |-ST
| | | | |-<
| | | | |-int
| | | | `->
| | | `-::
| | |-S
| | `-SimpleDeclarator
| | `-UnknownExpression
| | `-s2
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, QualifiedId_DecltypeSpecifier) { TEST_P(SyntaxTreeTest, QualifiedId_DecltypeSpecifier) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct S { struct S {
static void f(){} static void f(){}
}; };
void test(S s) { void test(S s) {
decltype(s)::f(); [[decltype(s)::f()]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit UnknownExpression
|-SimpleDeclaration |-IdExpression
| |-struct | |-NestedNameSpecifier
| |-S | | |-DecltypeNameSpecifier
| |-{ | | | |-decltype
| |-SimpleDeclaration
| | |-static
| | |-void
| | |-SimpleDeclarator
| | | |-f
| | | `-ParametersAndQualifiers
| | | |-( | | | |-(
| | | |-IdExpression
| | | | `-UnqualifiedId
| | | | `-s
| | | `-) | | | `-)
| | `-CompoundStatement | | `-::
| | |-{ | `-UnqualifiedId
| | `-} | `-f
| |-} |-(
| `-; `-)
`-SimpleDeclaration )txt"}));
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-S
| | `-SimpleDeclarator
| | `-s
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | |-NestedNameSpecifier
| | | | |-DecltypeNameSpecifier
| | | | | |-decltype
| | | | | |-(
| | | | | |-IdExpression
| | | | | | `-UnqualifiedId
| | | | | | `-s
| | | | | `-)
| | | | `-::
| | | `-UnqualifiedId
| | | `-f
| | |-(
| | `-)
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, QualifiedId_OptionalTemplateKw) { TEST_P(SyntaxTreeTest, QualifiedId_OptionalTemplateKw) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct S { struct S {
template<typename U> template<typename U>
static U f(); static U f();
}; };
void test() { void test() {
S::f<int>(); [[S::f<int>()]];
S::template f<int>(); [[S::template f<int>()]];
} }
)cpp", )cpp",
{R"txt(
UnknownExpression
|-IdExpression
| |-NestedNameSpecifier
| | |-IdentifierNameSpecifier
| | | `-S
| | `-::
| `-UnqualifiedId
| |-f
| |-<
| |-int
| `->
|-(
`-)
)txt",
R"txt( R"txt(
*: TranslationUnit UnknownExpression
|-SimpleDeclaration |-IdExpression
| |-struct | |-NestedNameSpecifier
| |-S | | |-IdentifierNameSpecifier
| |-{ | | | `-S
| |-TemplateDeclaration | | `-::
| | |-template | |-template
| | |-< | `-UnqualifiedId
| | |-UnknownDeclaration | |-f
| | | |-typename | |-<
| | | `-U | |-int
| | |-> | `->
| | `-SimpleDeclaration |-(
| | |-static `-)
| | |-U )txt"}));
| | |-SimpleDeclarator
| | | |-f
| | | `-ParametersAndQualifiers
| | | |-(
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | |-NestedNameSpecifier
| | | | |-IdentifierNameSpecifier
| | | | | `-S
| | | | `-::
| | | `-UnqualifiedId
| | | |-f
| | | |-<
| | | |-int
| | | `->
| | |-(
| | `-)
| `-;
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | |-NestedNameSpecifier
| | | | |-IdentifierNameSpecifier
| | | | | `-S
| | | | `-::
| | | |-template
| | | `-UnqualifiedId
| | | |-f
| | | |-<
| | | |-int
| | | `->
| | |-(
| | `-)
| `-;
`-}
)txt"));
} }
gribozavr2Unsubmitted
Done
ReplyInline Actions

The name of this test should be about declarations, and this test should be in the section of this file that has to do with declarations.

gribozavr2: The name of this test should be about declarations, and this test should be in the section of…
TEST_P(SyntaxTreeTest, QualifiedId_Complex) { TEST_P(SyntaxTreeTest, QualifiedId_Complex) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
namespace n { namespace n {
template<typename T> template<typename T>
struct ST { struct ST {
template<typename U> template<typename U>
static U f(); static U f();
}; };
} }
void test() { void test() {
::n::template ST<int>::template f<int>(); [[::n::template ST<int>::template f<int>()]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit UnknownExpression
|-NamespaceDefinition |-IdExpression
| |-namespace | |-NestedNameSpecifier
| |-n | | |-::
| |-{ | | |-IdentifierNameSpecifier
| |-TemplateDeclaration | | | `-n
| | |-template | | |-::
| | |-< | | |-SimpleTemplateNameSpecifier
| | |-UnknownDeclaration
| | | |-typename
| | | `-T
| | |->
| | `-SimpleDeclaration
| | |-struct
| | |-ST
| | |-{
| | |-TemplateDeclaration
| | | |-template
| | | |-<
| | | |-UnknownDeclaration
| | | | |-typename
| | | | `-U
| | | |->
| | | `-SimpleDeclaration
| | | |-static
| | | |-U
| | | |-SimpleDeclarator
| | | | |-f
| | | | `-ParametersAndQualifiers
| | | | |-(
| | | | `-)
| | | `-;
| | |-}
| | `-;
| `-}
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | |-NestedNameSpecifier
| | | | |-::
| | | | |-IdentifierNameSpecifier
| | | | | `-n
| | | | |-::
| | | | |-SimpleTemplateNameSpecifier
| | | | | |-template
| | | | | |-ST
| | | | | |-<
| | | | | |-int
| | | | | `->
| | | | `-::
| | | |-template | | | |-template
| | | `-UnqualifiedId | | | |-ST
| | | |-f
| | | |-< | | | |-<
| | | |-int | | | |-int
| | | `-> | | | `->
| | |-( | | `-::
| | `-) | |-template
| `-; | `-UnqualifiedId
`-} | |-f
)txt")); | |-<
| |-int
| `->
|-(
`-)
)txt"}));
} }
TEST_P(SyntaxTreeTest, QualifiedId_DependentType) { TEST_P(SyntaxTreeTest, QualifiedId_DependentType) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
if (GetParam().hasDelayedTemplateParsing()) { if (GetParam().hasDelayedTemplateParsing()) {
// FIXME: Make this test work on Windows by generating the expected syntax // FIXME: Make this test work on Windows by generating the expected syntax
// tree when `-fdelayed-template-parsing` is active. // tree when `-fdelayed-template-parsing` is active.
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
template <typename T> template <typename T>
void test() { void test() {
T::template U<int>::f(); [[T::template U<int>::f()]];
T::U::f(); [[T::U::f()]];
T::template f<0>(); [[T::template f<0>()]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit UnknownExpression
`-TemplateDeclaration |-IdExpression
|-template | |-NestedNameSpecifier
|-< | | |-IdentifierNameSpecifier
|-UnknownDeclaration | | | `-T
| |-typename | | |-::
| `-T | | |-SimpleTemplateNameSpecifier
|->
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | |-NestedNameSpecifier
| | | | |-IdentifierNameSpecifier
| | | | | `-T
| | | | |-::
| | | | |-SimpleTemplateNameSpecifier
| | | | | |-template
| | | | | |-U
| | | | | |-<
| | | | | |-int
| | | | | `->
| | | | `-::
| | | `-UnqualifiedId
| | | `-f
| | |-(
| | `-)
| `-;
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | |-NestedNameSpecifier
| | | | |-IdentifierNameSpecifier
| | | | | `-T
| | | | |-::
| | | | |-IdentifierNameSpecifier
| | | | | `-U
| | | | `-::
| | | `-UnqualifiedId
| | | `-f
| | |-(
| | `-)
| `-;
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | |-NestedNameSpecifier
| | | | |-IdentifierNameSpecifier
| | | | | `-T
| | | | `-::
| | | |-template | | | |-template
| | | `-UnqualifiedId | | | |-U
| | | |-f
| | | |-< | | | |-<
| | | |-IntegerLiteralExpression | | | |-int
| | | | `-0
| | | `-> | | | `->
| | |-( | | `-::
| | `-) | `-UnqualifiedId
| `-; | `-f
`-} |-(
)txt")); `-)
)txt",
R"txt(
UnknownExpression
|-IdExpression
| |-NestedNameSpecifier
| | |-IdentifierNameSpecifier
| | | `-T
| | |-::
| | |-IdentifierNameSpecifier
| | | `-U
| | `-::
| `-UnqualifiedId
| `-f
|-(
`-)
)txt",
R"txt(
UnknownExpression
|-IdExpression
| |-NestedNameSpecifier
| | |-IdentifierNameSpecifier
| | | `-T
| | `-::
| |-template
| `-UnqualifiedId
| |-f
| |-<
| |-IntegerLiteralExpression
| | `-0
| `->
|-(
`-)
)txt"}));
} }
TEST_P(SyntaxTreeTest, ParenExpr) { TEST_P(SyntaxTreeTest, ParenExpr) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
(1); [[(1)]];
((1)); [[((1))]];
(1 + (2)); [[(1 + (2))]];
} }
)cpp", )cpp",
{R"txt(
ParenExpression
|-(
|-IntegerLiteralExpression
| `-1
`-)
)txt",
R"txt( R"txt(
*: TranslationUnit ParenExpression
`-SimpleDeclaration |-(
|-void |-ParenExpression
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-( | |-(
| |-IntegerLiteralExpression
| | `-1
| `-) | `-)
`-CompoundStatement `-)
|-{ )txt",
|-ExpressionStatement R"txt(
| |-ParenExpression ParenExpression
| | |-( |-(
| | |-IntegerLiteralExpression |-BinaryOperatorExpression
| | | `-1 | |-IntegerLiteralExpression
| | `-) | | `-1
| `-; | |-+
|-ExpressionStatement | `-ParenExpression
| |-ParenExpression | |-(
| | |-( | |-IntegerLiteralExpression
| | |-ParenExpression | | `-2
| | | |-( | `-)
| | | |-IntegerLiteralExpression `-)
| | | | `-1 )txt"}));
| | | `-)
| | `-)
| `-;
|-ExpressionStatement
| |-ParenExpression
| | |-(
| | |-BinaryOperatorExpression
| | | |-IntegerLiteralExpression
| | | | `-1
| | | |-+
| | | `-ParenExpression
| | | |-(
| | | |-IntegerLiteralExpression
| | | | `-2
| | | `-)
| | `-)
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, UserDefinedLiteral_Char) { TEST_P(SyntaxTreeTest, UserDefinedLiteral_Char) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
unsigned operator "" _c(char); unsigned operator "" _c(char);
void test() { void test() {
'2'_c; [['2'_c]];
} }
)cpp", )cpp",
R"txt( {R"txt(
gribozavr2Unsubmitted
Done
ReplyInline Actions

The name of this test should be only about typedefs, and not about user-defined literals. The test should be also in the section of this file that is about declarations (down below).

gribozavr2: The name of this test should be only about typedefs, and not about user-defined literals. The…
*: TranslationUnit CharUserDefinedLiteralExpression
|-SimpleDeclaration `-'2'_c
| |-unsigned )txt"}));
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_c
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | `-char
| | `-)
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-CharUserDefinedLiteralExpression
| | `-'2'_c
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, UserDefinedLiteral_String) { TEST_P(SyntaxTreeTest, UserDefinedLiteral_String) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
typedef decltype(sizeof(void *)) size_t; typedef decltype(sizeof(void *)) size_t;
unsigned operator "" _s(const char*, size_t); unsigned operator "" _s(const char*, size_t);
void test() { void test() {
"12"_s; [["12"_s]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit StringUserDefinedLiteralExpression
|-SimpleDeclaration `-"12"_s
| |-typedef )txt"}));
| |-decltype
| |-(
| |-UnknownExpression
| | |-sizeof
| | |-(
| | |-void
| | |-*
| | `-)
| |-)
| |-SimpleDeclarator
| | `-size_t
| `-;
|-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_s
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | |-const
| | | |-char
| | | `-SimpleDeclarator
| | | `-*
| | |-,
| | |-SimpleDeclaration
| | | `-size_t
| | `-)
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-StringUserDefinedLiteralExpression
| | `-"12"_s
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, UserDefinedLiteral_Integer) { TEST_P(SyntaxTreeTest, UserDefinedLiteral_Integer) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
unsigned operator "" _i(unsigned long long); unsigned operator "" _i(unsigned long long);
unsigned operator "" _r(const char*); unsigned operator "" _r(const char*);
template <char...> template <char...>
unsigned operator "" _t(); unsigned operator "" _t();
void test() { void test() {
12_i; [[12_i]];
12_r; [[12_r]];
12_t; [[12_t]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit IntegerUserDefinedLiteralExpression
|-SimpleDeclaration `-12_i
| |-unsigned )txt",
| |-SimpleDeclarator R"txt(
| | |-operator IntegerUserDefinedLiteralExpression
| | |-"" `-12_r
| | |-_i )txt",
| | `-ParametersAndQualifiers R"txt(
| | |-( IntegerUserDefinedLiteralExpression
| | |-SimpleDeclaration `-12_t
| | | |-unsigned )txt"}));
| | | |-long
| | | `-long
| | `-)
| `-;
|-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_r
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | |-const
| | | |-char
| | | `-SimpleDeclarator
| | | `-*
| | `-)
| `-;
|-TemplateDeclaration
| |-template
| |-<
| |-SimpleDeclaration
| | `-char
| |-...
| |->
| `-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_t
| | `-ParametersAndQualifiers
| | |-(
| | `-)
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-IntegerUserDefinedLiteralExpression
| | `-12_i
| `-;
|-ExpressionStatement
| |-IntegerUserDefinedLiteralExpression
| | `-12_r
| `-;
|-ExpressionStatement
| |-IntegerUserDefinedLiteralExpression
| | `-12_t
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, UserDefinedLiteral_Float) { TEST_P(SyntaxTreeTest, UserDefinedLiteral_Float) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
unsigned operator "" _f(long double); unsigned operator "" _f(long double);
unsigned operator "" _r(const char*); unsigned operator "" _r(const char*);
template <char...> template <char...>
unsigned operator "" _t(); unsigned operator "" _t();
void test() { void test() {
1.2_f; // call: operator "" _f(1.2L) | kind: float [[1.2_f]];
1.2_r; // call: operator "" _i("1.2") | kind: float [[1.2_r]];
1.2_t; // call: operator<'1', '2'> "" _x() | kind: float [[1.2_t]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit FloatUserDefinedLiteralExpression
|-SimpleDeclaration `-1.2_f
| |-unsigned )txt",
| |-SimpleDeclarator R"txt(
| | |-operator FloatUserDefinedLiteralExpression
| | |-"" `-1.2_r
| | |-_f )txt",
| | `-ParametersAndQualifiers R"txt(
| | |-( FloatUserDefinedLiteralExpression
| | |-SimpleDeclaration `-1.2_t
| | | |-long )txt"}));
| | | `-double
| | `-)
| `-;
|-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_r
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | |-const
| | | |-char
| | | `-SimpleDeclarator
| | | `-*
| | `-)
| `-;
|-TemplateDeclaration
| |-template
| |-<
| |-SimpleDeclaration
| | `-char
| |-...
| |->
| `-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_t
| | `-ParametersAndQualifiers
| | |-(
| | `-)
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-FloatUserDefinedLiteralExpression
| | `-1.2_f
| `-;
|-ExpressionStatement
| |-FloatUserDefinedLiteralExpression
| | `-1.2_r
| `-;
|-ExpressionStatement
| |-FloatUserDefinedLiteralExpression
| | `-1.2_t
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, IntegerLiteral_LongLong) { TEST_P(SyntaxTreeTest, IntegerLiteral_LongLong) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
12ll; [[12ll]];
12ull; [[12ull]];
} }
)cpp", )cpp",
{R"txt(
IntegerLiteralExpression
`-12ll
)txt",
R"txt( R"txt(
*: TranslationUnit IntegerLiteralExpression
`-SimpleDeclaration `-12ull
|-void )txt"}));
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-IntegerLiteralExpression
| | `-12ll
| `-;
|-ExpressionStatement
| |-IntegerLiteralExpression
| | `-12ull
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, IntegerLiteral_Binary) { TEST_P(SyntaxTreeTest, IntegerLiteral_Binary) {
if (!GetParam().isCXX14OrLater()) { if (!GetParam().isCXX14OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
0b1100; [[0b1100]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit IntegerLiteralExpression
`-SimpleDeclaration `-0b1100
|-void )txt"}));
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-IntegerLiteralExpression
| | `-0b1100
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, IntegerLiteral_WithDigitSeparators) { TEST_P(SyntaxTreeTest, IntegerLiteral_WithDigitSeparators) {
if (!GetParam().isCXX14OrLater()) { if (!GetParam().isCXX14OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
1'2'0ull; [[1'2'0ull]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit IntegerLiteralExpression
`-SimpleDeclaration `-1'2'0ull
|-void )txt"}));
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-IntegerLiteralExpression
| | `-1'2'0ull
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, CharacterLiteral) { TEST_P(SyntaxTreeTest, CharacterLiteral) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
'a'; [['a']];
'\n'; [['\n']];
'\x20'; [['\x20']];
'\0'; [['\0']];
L'a'; [[L'a']];
L'α'; [[L'α']];
} }
)cpp", )cpp",
{R"txt(
CharacterLiteralExpression
`-'a'
)txt",
R"txt( R"txt(
*: TranslationUnit CharacterLiteralExpression
`-SimpleDeclaration `-'\n'
|-void )txt",
|-SimpleDeclarator R"txt(
| |-test CharacterLiteralExpression
| `-ParametersAndQualifiers `-'\x20'
| |-( )txt",
| `-) R"txt(
`-CompoundStatement CharacterLiteralExpression
|-{ `-'\0'
|-ExpressionStatement )txt",
| |-CharacterLiteralExpression R"txt(
| | `-'a' CharacterLiteralExpression
| `-; `-L'a'
|-ExpressionStatement )txt",
| |-CharacterLiteralExpression R"txt(
| | `-'\n' CharacterLiteralExpression
| `-; `-L'α'
|-ExpressionStatement )txt"}));
| |-CharacterLiteralExpression
| | `-'\x20'
| `-;
|-ExpressionStatement
| |-CharacterLiteralExpression
| | `-'\0'
| `-;
|-ExpressionStatement
| |-CharacterLiteralExpression
| | `-L'a'
| `-;
|-ExpressionStatement
| |-CharacterLiteralExpression
| | `-L'α'
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, CharacterLiteral_Utf) { TEST_P(SyntaxTreeTest, CharacterLiteral_Utf) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
u'a'; [[u'a']];
u'構'; [[u'構']];
U'a'; [[U'a']];
U'🌲'; [[U'🌲']];
} }
)cpp", )cpp",
{R"txt(
CharacterLiteralExpression
`-u'a'
)txt",
R"txt( R"txt(
*: TranslationUnit CharacterLiteralExpression
`-SimpleDeclaration `-u'構'
|-void )txt",
|-SimpleDeclarator R"txt(
| |-test CharacterLiteralExpression
| `-ParametersAndQualifiers `-U'a'
| |-( )txt",
| `-) R"txt(
`-CompoundStatement CharacterLiteralExpression
|-{ `-U'🌲'
|-ExpressionStatement )txt"}));
| |-CharacterLiteralExpression
| | `-u'a'
| `-;
|-ExpressionStatement
| |-CharacterLiteralExpression
| | `-u'構'
| `-;
|-ExpressionStatement
| |-CharacterLiteralExpression
| | `-U'a'
| `-;
|-ExpressionStatement
| |-CharacterLiteralExpression
| | `-U'🌲'
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, CharacterLiteral_Utf8) { TEST_P(SyntaxTreeTest, CharacterLiteral_Utf8) {
if (!GetParam().isCXX17OrLater()) { if (!GetParam().isCXX17OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
u8'a'; [[u8'a']];
u8'\x7f'; [[u8'\x7f']];
} }
)cpp", )cpp",
{R"txt(
CharacterLiteralExpression
`-u8'a'
)txt",
R"txt( R"txt(
*: TranslationUnit CharacterLiteralExpression
`-SimpleDeclaration `-u8'\x7f'
|-void )txt"}));
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-CharacterLiteralExpression
| | `-u8'a'
| `-;
|-ExpressionStatement
| |-CharacterLiteralExpression
| | `-u8'\x7f'
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, FloatingLiteral) { TEST_P(SyntaxTreeTest, FloatingLiteral) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
1e-2; [[1e-2]];
2.; [[2.]];
.2; [[.2]];
2.f; [[2.f]];
} }
)cpp", )cpp",
{R"txt(
FloatingLiteralExpression
`-1e-2
)txt",
R"txt( R"txt(
*: TranslationUnit FloatingLiteralExpression
`-SimpleDeclaration `-2.
|-void )txt",
|-SimpleDeclarator R"txt(
| |-test FloatingLiteralExpression
| `-ParametersAndQualifiers `-.2
| |-( )txt",
| `-) R"txt(
`-CompoundStatement FloatingLiteralExpression
|-{ `-2.f
|-ExpressionStatement )txt"}));
| |-FloatingLiteralExpression
| | `-1e-2
| `-;
|-ExpressionStatement
| |-FloatingLiteralExpression
| | `-2.
| `-;
|-ExpressionStatement
| |-FloatingLiteralExpression
| | `-.2
| `-;
|-ExpressionStatement
| |-FloatingLiteralExpression
| | `-2.f
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, FloatingLiteral_Hexadecimal) { TEST_P(SyntaxTreeTest, FloatingLiteral_Hexadecimal) {
if (!GetParam().isCXX17OrLater()) { if (!GetParam().isCXX17OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
0xfp1; [[0xfp1]];
0xf.p1; [[0xf.p1]];
0x.fp1; [[0x.fp1]];
0xf.fp1f; [[0xf.fp1f]];
} }
)cpp", )cpp",
{R"txt(
FloatingLiteralExpression
`-0xfp1
)txt",
R"txt( R"txt(
*: TranslationUnit FloatingLiteralExpression
`-SimpleDeclaration `-0xf.p1
|-void )txt",
|-SimpleDeclarator R"txt(
| |-test FloatingLiteralExpression
| `-ParametersAndQualifiers `-0x.fp1
| |-( )txt",
| `-) R"txt(
`-CompoundStatement FloatingLiteralExpression
|-{ `-0xf.fp1f
|-ExpressionStatement )txt"}));
| |-FloatingLiteralExpression
| | `-0xfp1
| `-;
|-ExpressionStatement
| |-FloatingLiteralExpression
| | `-0xf.p1
| `-;
|-ExpressionStatement
| |-FloatingLiteralExpression
| | `-0x.fp1
| `-;
|-ExpressionStatement
| |-FloatingLiteralExpression
| | `-0xf.fp1f
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, StringLiteral) { TEST_P(SyntaxTreeTest, StringLiteral) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
"a\n\0\x20"; [["a\n\0\x20"]];
L"αβ"; [[L"αβ"]];
} }
)cpp", )cpp",
{R"txt(
StringLiteralExpression
`-"a\n\0\x20"
)txt",
R"txt( R"txt(
*: TranslationUnit StringLiteralExpression
`-SimpleDeclaration `-L"αβ"
|-void )txt"}));
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-StringLiteralExpression
| | `-"a\n\0\x20"
| `-;
|-ExpressionStatement
| |-StringLiteralExpression
| | `-L"αβ"
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, StringLiteral_Utf) { TEST_P(SyntaxTreeTest, StringLiteral_Utf) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
u8"a\x1f\x05"; [[u8"a\x1f\x05"]];
u"C++抽象構文木"; [[u"C++抽象構文木"]];
U"📖🌲\n"; [[U"📖🌲\n"]];
} }
)cpp", )cpp",
{R"txt(
StringLiteralExpression
`-u8"a\x1f\x05"
)txt",
R"txt( R"txt(
*: TranslationUnit StringLiteralExpression
`-SimpleDeclaration `-u"C++抽象構文木"
|-void )txt",
|-SimpleDeclarator R"txt(
| |-test StringLiteralExpression
| `-ParametersAndQualifiers `-U"📖🌲\n"
| |-( )txt"}));
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-StringLiteralExpression
| | `-u8"a\x1f\x05"
| `-;
|-ExpressionStatement
| |-StringLiteralExpression
| | `-u"C++抽象構文木"
| `-;
|-ExpressionStatement
| |-StringLiteralExpression
| | `-U"📖🌲\n"
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, StringLiteral_Raw) { TEST_P(SyntaxTreeTest, StringLiteral_Raw) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
// This test uses regular string literals instead of raw string literals to // This test uses regular string literals instead of raw string literals to
// hold source code and expected output because of a bug in MSVC up to MSVC // hold source code and expected output because of a bug in MSVC up to MSVC
Show All 23 Lines EXPECT_TRUE(treeDumpEqual( //
" | `-;\n" " | `-;\n"
" `-}\n")); " `-}\n"));
} }
TEST_P(SyntaxTreeTest, BoolLiteral) { TEST_P(SyntaxTreeTest, BoolLiteral) {
if (GetParam().isC()) { if (GetParam().isC()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
true; [[true]];
false; [[false]];
} }
)cpp", )cpp",
{R"txt(
BoolLiteralExpression
`-true
)txt",
R"txt( R"txt(
*: TranslationUnit BoolLiteralExpression
`-SimpleDeclaration `-false
|-void )txt"}));
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-BoolLiteralExpression
| | `-true
| `-;
|-ExpressionStatement
| |-BoolLiteralExpression
| | `-false
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) { TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
nullptr; [[nullptr]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit CxxNullPtrExpression
`-SimpleDeclaration `-nullptr
|-void )txt"}));
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-CxxNullPtrExpression
| | `-nullptr
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, PostfixUnaryOperator) { TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test(int a) { void test(int a) {
a++; [[a++]];
a--; [[a--]];
} }
)cpp", )cpp",
{R"txt(
PostfixUnaryOperatorExpression
|-IdExpression
| `-UnqualifiedId
| `-a
`-++
)txt",
R"txt( R"txt(
*: TranslationUnit PostfixUnaryOperatorExpression
`-SimpleDeclaration |-IdExpression
|-void | `-UnqualifiedId
|-SimpleDeclarator | `-a
| |-test `---
| `-ParametersAndQualifiers )txt"}));
| |-(
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | `-a
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-PostfixUnaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-a
| | `-++
| `-;
|-ExpressionStatement
| |-PostfixUnaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-a
| | `---
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, PrefixUnaryOperator) { TEST_P(SyntaxTreeTest, PrefixUnaryOperator) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test(int a, int *ap) { void test(int a, int *ap) {
--a; ++a; [[--a]]; [[++a]];
~a; [[~a]];
-a; [[-a]];
+a; [[+a]];
&a; [[&a]];
*ap; [[*ap]];
!a; [[!a]];
__real a; __imag a; [[__real a]]; [[__imag a]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit PrefixUnaryOperatorExpression
`-SimpleDeclaration |---
|-void `-IdExpression
|-SimpleDeclarator `-UnqualifiedId
| |-test `-a
| `-ParametersAndQualifiers )txt",
| |-( R"txt(
| |-SimpleDeclaration PrefixUnaryOperatorExpression
| | |-int |-++
| | `-SimpleDeclarator `-IdExpression
| | `-a `-UnqualifiedId
| |-, `-a
| |-SimpleDeclaration )txt",
| | |-int R"txt(
| | `-SimpleDeclarator PrefixUnaryOperatorExpression
| | |-* |-~
| | `-ap `-IdExpression
| `-) `-UnqualifiedId
`-CompoundStatement `-a
|-{ )txt",
|-ExpressionStatement R"txt(
| |-PrefixUnaryOperatorExpression PrefixUnaryOperatorExpression
| | |--- |--
| | `-IdExpression `-IdExpression
| | `-UnqualifiedId `-UnqualifiedId
| | `-a `-a
| `-; )txt",
|-ExpressionStatement R"txt(
| |-PrefixUnaryOperatorExpression PrefixUnaryOperatorExpression
| | |-++ |-+
| | `-IdExpression `-IdExpression
| | `-UnqualifiedId `-UnqualifiedId
| | `-a `-a
| `-; )txt",
|-ExpressionStatement R"txt(
| |-PrefixUnaryOperatorExpression PrefixUnaryOperatorExpression
| | |-~ |-&
| | `-IdExpression `-IdExpression
| | `-UnqualifiedId `-UnqualifiedId
| | `-a `-a
| `-; )txt",
|-ExpressionStatement R"txt(
| |-PrefixUnaryOperatorExpression PrefixUnaryOperatorExpression
| | |-- |-*
| | `-IdExpression `-IdExpression
| | `-UnqualifiedId `-UnqualifiedId
| | `-a `-ap
| `-; )txt",
|-ExpressionStatement R"txt(
| |-PrefixUnaryOperatorExpression PrefixUnaryOperatorExpression
| | |-+ |-!
| | `-IdExpression `-IdExpression
| | `-UnqualifiedId `-UnqualifiedId
| | `-a `-a
| `-; )txt",
|-ExpressionStatement R"txt(
| |-PrefixUnaryOperatorExpression PrefixUnaryOperatorExpression
| | |-& |-__real
| | `-IdExpression `-IdExpression
| | `-UnqualifiedId `-UnqualifiedId
| | `-a `-a
| `-; )txt",
|-ExpressionStatement R"txt(
| |-PrefixUnaryOperatorExpression PrefixUnaryOperatorExpression
| | |-* |-__imag
| | `-IdExpression `-IdExpression
| | `-UnqualifiedId `-UnqualifiedId
| | `-ap `-a
| `-; )txt"}));
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-!
| | `-IdExpression
| | `-UnqualifiedId
| | `-a
| `-;
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-__real
| | `-IdExpression
| | `-UnqualifiedId
| | `-a
| `-;
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-__imag
| | `-IdExpression
| | `-UnqualifiedId
| | `-a
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, PrefixUnaryOperatorCxx) { TEST_P(SyntaxTreeTest, PrefixUnaryOperatorCxx) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test(int a, bool b) { void test(int a, bool b) {
compl a; [[compl a]];
not b; [[not b]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit PrefixUnaryOperatorExpression
`-SimpleDeclaration |-compl
|-void `-IdExpression
|-SimpleDeclarator `-UnqualifiedId
| |-test `-a
| `-ParametersAndQualifiers )txt",
| |-( R"txt(
| |-SimpleDeclaration PrefixUnaryOperatorExpression
| | |-int |-not
| | `-SimpleDeclarator `-IdExpression
| | `-a `-UnqualifiedId
| |-, `-b
| |-SimpleDeclaration )txt"}));
| | |-bool
| | `-SimpleDeclarator
| | `-b
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-compl
| | `-IdExpression
| | `-UnqualifiedId
| | `-a
| `-;
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-not
| | `-IdExpression
| | `-UnqualifiedId
| | `-b
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, BinaryOperator) { TEST_P(SyntaxTreeTest, BinaryOperator) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test(int a) { void test(int a) {
1 - 2; [[1 - 2]];
1 == 2; [[1 == 2]];
a = 1; [[a = 1]];
a <<= 1; [[a <<= 1]];
1 || 0; [[1 || 0]];
1 & 2; [[1 & 2]];
a ^= 3; [[a != 3]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit BinaryOperatorExpression
`-SimpleDeclaration |-IntegerLiteralExpression
|-void | `-1
|-SimpleDeclarator |--
| |-test `-IntegerLiteralExpression
| `-ParametersAndQualifiers `-2
| |-( )txt",
| |-SimpleDeclaration R"txt(
| | |-int BinaryOperatorExpression
| | `-SimpleDeclarator |-IntegerLiteralExpression
| | `-a | `-1
| `-) |-==
`-CompoundStatement `-IntegerLiteralExpression
|-{ `-2
|-ExpressionStatement )txt",
| |-BinaryOperatorExpression R"txt(
| | |-IntegerLiteralExpression BinaryOperatorExpression
| | | `-1 |-IdExpression
| | |-- | `-UnqualifiedId
| | `-IntegerLiteralExpression | `-a
| | `-2 |-=
| `-; `-IntegerLiteralExpression
|-ExpressionStatement `-1
| |-BinaryOperatorExpression )txt",
| | |-IntegerLiteralExpression R"txt(
| | | `-1 BinaryOperatorExpression
| | |-== |-IdExpression
| | `-IntegerLiteralExpression | `-UnqualifiedId
| | `-2 | `-a
| `-; |-<<=
|-ExpressionStatement `-IntegerLiteralExpression
| |-BinaryOperatorExpression `-1
| | |-IdExpression )txt",
| | | `-UnqualifiedId R"txt(
| | | `-a BinaryOperatorExpression
| | |-= |-IntegerLiteralExpression
| | `-IntegerLiteralExpression | `-1
| | `-1 |-||
| `-; `-IntegerLiteralExpression
|-ExpressionStatement `-0
| |-BinaryOperatorExpression )txt",
| | |-IdExpression R"txt(
| | | `-UnqualifiedId BinaryOperatorExpression
| | | `-a |-IntegerLiteralExpression
| | |-<<= | `-1
| | `-IntegerLiteralExpression |-&
| | `-1 `-IntegerLiteralExpression
| `-; `-2
|-ExpressionStatement )txt",
| |-BinaryOperatorExpression R"txt(
| | |-IntegerLiteralExpression BinaryOperatorExpression
| | | `-1 |-IdExpression
| | |-|| | `-UnqualifiedId
| | `-IntegerLiteralExpression | `-a
| | `-0 |-!=
| `-; `-IntegerLiteralExpression
|-ExpressionStatement `-3
| |-BinaryOperatorExpression )txt"}));
| | |-IntegerLiteralExpression
| | | `-1
| | |-&
| | `-IntegerLiteralExpression
| | `-2
| `-;
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-a
| | |-^=
| | `-IntegerLiteralExpression
| | `-3
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, BinaryOperatorCxx) { TEST_P(SyntaxTreeTest, BinaryOperatorCxx) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test(int a) { void test(int a) {
true || false; [[true || false]];
true or false; [[true or false]];
1 bitand 2; [[1 bitand 2]];
a xor_eq 3; [[a xor_eq 3]];
} }
)cpp", )cpp",
{R"txt(
BinaryOperatorExpression
|-BoolLiteralExpression
| `-true
|-||
`-BoolLiteralExpression
`-false
)txt",
R"txt( R"txt(
*: TranslationUnit BinaryOperatorExpression
`-SimpleDeclaration |-BoolLiteralExpression
|-void | `-true
|-SimpleDeclarator |-or
| |-test `-BoolLiteralExpression
| `-ParametersAndQualifiers `-false
| |-( )txt",
| |-SimpleDeclaration R"txt(
| | |-int BinaryOperatorExpression
| | `-SimpleDeclarator |-IntegerLiteralExpression
| | `-a | `-1
| `-) |-bitand
`-CompoundStatement `-IntegerLiteralExpression
|-{ `-2
|-ExpressionStatement )txt",
| |-BinaryOperatorExpression R"txt(
| | |-BoolLiteralExpression BinaryOperatorExpression
| | | `-true |-IdExpression
| | |-|| | `-UnqualifiedId
| | `-BoolLiteralExpression | `-a
| | `-false |-xor_eq
| `-; `-IntegerLiteralExpression
|-ExpressionStatement `-3
| |-BinaryOperatorExpression )txt"}));
| | |-BoolLiteralExpression
| | | `-true
| | |-or
| | `-BoolLiteralExpression
| | `-false
| `-;
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IntegerLiteralExpression
| | | `-1
| | |-bitand
| | `-IntegerLiteralExpression
| | `-2
| `-;
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-a
| | |-xor_eq
| | `-IntegerLiteralExpression
| | `-3
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, BinaryOperator_NestedWithParenthesis) { TEST_P(SyntaxTreeTest, BinaryOperator_NestedWithParenthesis) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
(1 + 2) * (4 / 2); [[(1 + 2) * (4 / 2)]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit BinaryOperatorExpression
`-SimpleDeclaration |-ParenExpression
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-( | |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-BinaryOperatorExpression | |-BinaryOperatorExpression
| | |-ParenExpression | | |-IntegerLiteralExpression
| | | |-( | | | `-1
| | | |-BinaryOperatorExpression | | |-+
| | | | |-IntegerLiteralExpression | | `-IntegerLiteralExpression
| | | | | `-1 | | `-2
| | | | |-+ | `-)
| | | | `-IntegerLiteralExpression |-*
| | | | `-2 `-ParenExpression
| | | `-) |-(
| | |-* |-BinaryOperatorExpression
| | `-ParenExpression | |-IntegerLiteralExpression
| | |-( | | `-4
| | |-BinaryOperatorExpression | |-/
| | | |-IntegerLiteralExpression | `-IntegerLiteralExpression
| | | | `-4 | `-2
| | | |-/ `-)
| | | `-IntegerLiteralExpression )txt"}));
| | | `-2
| | `-)
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, BinaryOperator_Associativity) { TEST_P(SyntaxTreeTest, BinaryOperator_Associativity) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test(int a, int b) { void test(int a, int b) {
a + b + 42; [[a + b + 42]];
a = b = 42; [[a = b = 42]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit BinaryOperatorExpression
`-SimpleDeclaration |-BinaryOperatorExpression
|-void | |-IdExpression
|-SimpleDeclarator | | `-UnqualifiedId
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | `-a | | `-a
| |-, | |-+
| |-SimpleDeclaration | `-IdExpression
| | |-int | `-UnqualifiedId
| | `-SimpleDeclarator | `-b
| | `-b |-+
| `-) `-IntegerLiteralExpression
`-CompoundStatement `-42
|-{ )txt",
|-ExpressionStatement R"txt(
| |-BinaryOperatorExpression BinaryOperatorExpression
| | |-BinaryOperatorExpression |-IdExpression
| | | |-IdExpression | `-UnqualifiedId
| | | | `-UnqualifiedId | `-a
| | | | `-a |-=
| | | |-+ `-BinaryOperatorExpression
| | | `-IdExpression |-IdExpression
| | | `-UnqualifiedId | `-UnqualifiedId
| | | `-b | `-b
| | |-+ |-=
| | `-IntegerLiteralExpression `-IntegerLiteralExpression
| | `-42 `-42
| `-; )txt"}));
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-a
| | |-=
| | `-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-b
| | |-=
| | `-IntegerLiteralExpression
| | `-42
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, BinaryOperator_Precedence) { TEST_P(SyntaxTreeTest, BinaryOperator_Precedence) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
1 + 2 * 3 + 4; [[1 + 2 * 3 + 4]];
1 % 2 + 3 * 4; [[1 % 2 + 3 * 4]];
} }
)cpp", )cpp",
{R"txt(
BinaryOperatorExpression
|-BinaryOperatorExpression
| |-IntegerLiteralExpression
| | `-1
| |-+
| `-BinaryOperatorExpression
| |-IntegerLiteralExpression
| | `-2
| |-*
| `-IntegerLiteralExpression
| `-3
|-+
`-IntegerLiteralExpression
`-4
)txt",
R"txt( R"txt(
*: TranslationUnit BinaryOperatorExpression
`-SimpleDeclaration |-BinaryOperatorExpression
|-void | |-IntegerLiteralExpression
|-SimpleDeclarator | | `-1
| |-test | |-%
| `-ParametersAndQualifiers | `-IntegerLiteralExpression
| |-( | `-2
| `-) |-+
`-CompoundStatement `-BinaryOperatorExpression
|-{ |-IntegerLiteralExpression
|-ExpressionStatement | `-3
| |-BinaryOperatorExpression |-*
| | |-BinaryOperatorExpression `-IntegerLiteralExpression
| | | |-IntegerLiteralExpression `-4
| | | | `-1 )txt"}));
| | | |-+
| | | `-BinaryOperatorExpression
| | | |-IntegerLiteralExpression
| | | | `-2
| | | |-*
| | | `-IntegerLiteralExpression
| | | `-3
| | |-+
| | `-IntegerLiteralExpression
| | `-4
| `-;
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-BinaryOperatorExpression
| | | |-IntegerLiteralExpression
| | | | `-1
| | | |-%
| | | `-IntegerLiteralExpression
| | | `-2
| | |-+
| | `-BinaryOperatorExpression
| | |-IntegerLiteralExpression
| | | `-3
| | |-*
| | `-IntegerLiteralExpression
| | `-4
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, OverloadedOperator_Assignment) { TEST_P(SyntaxTreeTest, OverloadedOperator_Assignment) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
X& operator=(const X&); X& operator=(const X&);
}; };
void test(X x, X y) { void test(X x, X y) {
x = y; [[x = y]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit BinaryOperatorExpression
|-SimpleDeclaration |-IdExpression
| |-struct | `-UnqualifiedId
| |-X | `-x
| |-{ |-=
| |-SimpleDeclaration `-IdExpression
| | |-X `-UnqualifiedId
| | |-SimpleDeclarator `-y
| | | |-& )txt"}));
| | | |-operator
| | | |-=
| | | `-ParametersAndQualifiers
| | | |-(
| | | |-SimpleDeclaration
| | | | |-const
| | | | |-X
| | | | `-SimpleDeclarator
| | | | `-&
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| |-,
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-y
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | |-=
| | `-IdExpression
| | `-UnqualifiedId
| | `-y
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, OverloadedOperator_Plus) { TEST_P(SyntaxTreeTest, OverloadedOperator_Plus) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
friend X operator+(X, const X&); friend X operator+(X, const X&);
}; };
void test(X x, X y) { void test(X x, X y) {
x + y; [[x + y]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit BinaryOperatorExpression
|-SimpleDeclaration |-UnknownExpression
| |-struct | `-IdExpression
| |-X | `-UnqualifiedId
| |-{ | `-x
| |-UnknownDeclaration |-+
| | `-SimpleDeclaration `-IdExpression
| | |-friend `-UnqualifiedId
| | |-X `-y
| | |-SimpleDeclarator )txt"}));
| | | |-operator
| | | |-+
| | | `-ParametersAndQualifiers
| | | |-(
| | | |-SimpleDeclaration
| | | | `-X
| | | |-,
| | | |-SimpleDeclaration
| | | | |-const
| | | | |-X
| | | | `-SimpleDeclarator
| | | | `-&
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| |-,
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-y
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-UnknownExpression
| | | `-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | |-+
| | `-IdExpression
| | `-UnqualifiedId
| | `-y
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, OverloadedOperator_Less) { TEST_P(SyntaxTreeTest, OverloadedOperator_Less) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
friend bool operator<(const X&, const X&); friend bool operator<(const X&, const X&);
}; };
void test(X x, X y) { void test(X x, X y) {
x < y; [[x < y]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit BinaryOperatorExpression
|-SimpleDeclaration |-IdExpression
| |-struct | `-UnqualifiedId
| |-X | `-x
| |-{ |-<
| |-UnknownDeclaration `-IdExpression
| | `-SimpleDeclaration `-UnqualifiedId
| | |-friend `-y
| | |-bool )txt"}));
| | |-SimpleDeclarator
| | | |-operator
| | | |-<
| | | `-ParametersAndQualifiers
| | | |-(
| | | |-SimpleDeclaration
| | | | |-const
| | | | |-X
| | | | `-SimpleDeclarator
| | | | `-&
| | | |-,
| | | |-SimpleDeclaration
| | | | |-const
| | | | |-X
| | | | `-SimpleDeclarator
| | | | `-&
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| |-,
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-y
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | |-<
| | `-IdExpression
| | `-UnqualifiedId
| | `-y
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, OverloadedOperator_LeftShift) { TEST_P(SyntaxTreeTest, OverloadedOperator_LeftShift) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
friend X operator<<(X&, const X&); friend X operator<<(X&, const X&);
}; };
void test(X x, X y) { void test(X x, X y) {
x << y; [[x << y]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit BinaryOperatorExpression
|-SimpleDeclaration |-IdExpression
| |-struct | `-UnqualifiedId
| |-X | `-x
| |-{ |-<<
| |-UnknownDeclaration `-IdExpression
| | `-SimpleDeclaration `-UnqualifiedId
| | |-friend `-y
| | |-X )txt"}));
| | |-SimpleDeclarator
| | | |-operator
| | | |-<<
| | | `-ParametersAndQualifiers
| | | |-(
| | | |-SimpleDeclaration
| | | | |-X
| | | | `-SimpleDeclarator
| | | | `-&
| | | |-,
| | | |-SimpleDeclaration
| | | | |-const
| | | | |-X
| | | | `-SimpleDeclarator
| | | | `-&
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| |-,
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-y
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | |-<<
| | `-IdExpression
| | `-UnqualifiedId
| | `-y
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, OverloadedOperator_Comma) { TEST_P(SyntaxTreeTest, OverloadedOperator_Comma) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
X operator,(X&); X operator,(X&);
}; };
void test(X x, X y) { void test(X x, X y) {
x, y; [[x, y]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit BinaryOperatorExpression
|-SimpleDeclaration |-IdExpression
| |-struct | `-UnqualifiedId
| |-X | `-x
| |-{ |-,
| |-SimpleDeclaration `-IdExpression
| | |-X `-UnqualifiedId
| | |-SimpleDeclarator `-y
| | | |-operator )txt"}));
| | | |-,
| | | `-ParametersAndQualifiers
| | | |-(
| | | |-SimpleDeclaration
| | | | |-X
| | | | `-SimpleDeclarator
| | | | `-&
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| |-,
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-y
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | |-,
| | `-IdExpression
| | `-UnqualifiedId
| | `-y
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, OverloadedOperator_PointerToMember) { TEST_P(SyntaxTreeTest, OverloadedOperator_PointerToMember) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
X operator->*(int); X operator->*(int);
}; };
void test(X* xp, int X::* pmi) { void test(X* xp, int X::* pmi) {
xp->*pmi; [[xp->*pmi]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit BinaryOperatorExpression
|-SimpleDeclaration |-IdExpression
| |-struct | `-UnqualifiedId
| |-X | `-xp
| |-{ |-->*
| |-SimpleDeclaration `-IdExpression
| | |-X `-UnqualifiedId
| | |-SimpleDeclarator `-pmi
| | | |-operator )txt"}));
| | | |-->*
| | | `-ParametersAndQualifiers
| | | |-(
| | | |-SimpleDeclaration
| | | | `-int
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | |-*
| | `-xp
| |-,
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | |-MemberPointer
| | | |-X
| | | |-::
| | | `-*
| | `-pmi
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-xp
| | |-->*
| | `-IdExpression
| | `-UnqualifiedId
| | `-pmi
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, OverloadedOperator_Negation) { TEST_P(SyntaxTreeTest, OverloadedOperator_Negation) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
bool operator!(); bool operator!();
}; };
void test(X x) { void test(X x) {
!x; [[!x]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit PrefixUnaryOperatorExpression
|-SimpleDeclaration |-!
| |-struct `-IdExpression
| |-X `-UnqualifiedId
| |-{ `-x
| |-SimpleDeclaration )txt"}));
| | |-bool
| | |-SimpleDeclarator
| | | |-operator
| | | |-!
| | | `-ParametersAndQualifiers
| | | |-(
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-!
| | `-IdExpression
| | `-UnqualifiedId
| | `-x
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, OverloadedOperator_AddressOf) { TEST_P(SyntaxTreeTest, OverloadedOperator_AddressOf) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
X* operator&(); X* operator&();
}; };
void test(X x) { void test(X x) {
&x; [[&x]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit PrefixUnaryOperatorExpression
|-SimpleDeclaration |-&
| |-struct `-IdExpression
| |-X `-UnqualifiedId
| |-{ `-x
| |-SimpleDeclaration )txt"}));
| | |-X
| | |-SimpleDeclarator
| | | |-*
| | | |-operator
| | | |-&
| | | `-ParametersAndQualifiers
| | | |-(
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-&
| | `-IdExpression
| | `-UnqualifiedId
| | `-x
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, OverloadedOperator_PrefixIncrement) { TEST_P(SyntaxTreeTest, OverloadedOperator_PrefixIncrement) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
X operator++(); X operator++();
}; };
void test(X x) { void test(X x) {
++x; [[++x]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit PrefixUnaryOperatorExpression
|-SimpleDeclaration |-++
| |-struct `-IdExpression
| |-X `-UnqualifiedId
| |-{ `-x
| |-SimpleDeclaration )txt"}));
| | |-X
| | |-SimpleDeclarator
| | | |-operator
| | | |-++
| | | `-ParametersAndQualifiers
| | | |-(
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-++
| | `-IdExpression
| | `-UnqualifiedId
| | `-x
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, OverloadedOperator_PostfixIncrement) { TEST_P(SyntaxTreeTest, OverloadedOperator_PostfixIncrement) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
struct X { struct X {
X operator++(int); X operator++(int);
}; };
void test(X x) { void test(X x) {
x++; [[x++]];
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit PostfixUnaryOperatorExpression
|-SimpleDeclaration |-IdExpression
| |-struct | `-UnqualifiedId
| |-X | `-x
| |-{ `-++
| |-SimpleDeclaration )txt"}));
| | |-X
| | |-SimpleDeclarator
| | | |-operator
| | | |-++
| | | `-ParametersAndQualifiers
| | | |-(
| | | |-SimpleDeclaration
| | | | `-int
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-PostfixUnaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | `-++
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) { TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
int *a, b; int *a, b;
int *c, d; int *c, d;
)cpp", )cpp",
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines `-CompoundStatement
| | |-, | | |-,
| | `-SimpleDeclarator | | `-SimpleDeclarator
| | `-tb | | `-tb
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, ComplexTypedef) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
typedef decltype(sizeof(void *)) size_t;
)cpp",
R"txt(
*: TranslationUnit
`-SimpleDeclaration
|-typedef
|-decltype
|-(
|-UnknownExpression
| |-sizeof
| |-(
| |-void
| |-*
| `-)
|-)
|-SimpleDeclarator
| `-size_t
`-;
)txt"));
}
TEST_P(SyntaxTreeTest, Namespaces) { TEST_P(SyntaxTreeTest, Namespaces) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
namespace a { namespace b {} } namespace a { namespace b {} }
namespace a::b {} namespace a::b {}
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines`-SimpleDeclaration
|-} |-}
|-SimpleDeclarator |-SimpleDeclarator
| |-* | |-*
| `-a1 | `-a1
`-; `-;
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, Templates) { TEST_P(SyntaxTreeTest, StaticMemberFunction) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct S {
static void f(){}
};
)cpp",
R"txt(
*: TranslationUnit
`-SimpleDeclaration
|-struct
|-S
|-{
|-SimpleDeclaration
| |-static
| |-void
| |-SimpleDeclarator
| | |-f
| | `-ParametersAndQualifiers
| | |-(
| | `-)
| `-CompoundStatement
| |-{
| `-}
|-}
`-;
)txt"));
}
TEST_P(SyntaxTreeTest, ConversionMemberFunction) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
if (GetParam().hasDelayedTemplateParsing()) { EXPECT_TRUE(treeDumpEqual(
// FIXME: Make this test work on Windows by generating the expected syntax R"cpp(
// tree when `-fdelayed-template-parsing` is active. struct X {
operator int();
};
)cpp",
R"txt(
*: TranslationUnit
`-SimpleDeclaration
|-struct
|-X
|-{
|-SimpleDeclaration
| |-SimpleDeclarator
| | |-operator
| | |-int
| | `-ParametersAndQualifiers
| | |-(
| | `-)
| `-;
|-}
`-;
)txt"));
}
TEST_P(SyntaxTreeTest, LiteralOperatorDeclaration) {
if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
template <class T> struct cls {}; unsigned operator "" _c(char);
template <class T> int var = 10;
template <class T> int fun() {}
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-TemplateDeclaration `-SimpleDeclaration
| |-template |-unsigned
| |-< |-SimpleDeclarator
| |-UnknownDeclaration | |-operator
| | |-class | |-""
| | `-T | |-_c
| |-> | `-ParametersAndQualifiers
| `-SimpleDeclaration | |-(
| |-struct | |-SimpleDeclaration
| |-cls | | `-char
| |-{ | `-)
| |-} `-;
)txt"));
}
TEST_P(SyntaxTreeTest, NumericLiteralOperatorTemplateDeclaration) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
template <char...>
unsigned operator "" _t();
)cpp",
R"txt(
*: TranslationUnit
`-TemplateDeclaration
|-template
|-<
|-SimpleDeclaration
| `-char
|-...
|->
`-SimpleDeclaration
|-unsigned
|-SimpleDeclarator
| |-operator
| |-""
| |-_t
| `-ParametersAndQualifiers
| |-(
| `-)
`-;
)txt"));
}
TEST_P(SyntaxTreeTest, OverloadedOperatorDeclaration) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
X& operator=(const X&);
};
)cpp",
R"txt(
*: TranslationUnit
`-SimpleDeclaration
|-struct
|-X
|-{
|-SimpleDeclaration
| |-X
| |-SimpleDeclarator
| | |-&
| | |-operator
| | |-=
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | |-const
| | | |-X
| | | `-SimpleDeclarator
| | | `-&
| | `-)
| `-; | `-;
|-TemplateDeclaration |-}
| |-template `-;
| |-< )txt"));
| |-UnknownDeclaration }
| | |-class
| | `-T TEST_P(SyntaxTreeTest, OverloadedOperatorFriendDeclarataion) {
| |-> if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
friend X operator+(X, const X&);
};
)cpp",
R"txt(
*: TranslationUnit
`-SimpleDeclaration
|-struct
|-X
|-{
|-UnknownDeclaration
| `-SimpleDeclaration | `-SimpleDeclaration
| |-int | |-friend
| |-X
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-var | | |-operator
| | |-= | | |-+
| | `-IntegerLiteralExpression | | `-ParametersAndQualifiers
| | `-10 | | |-(
| | |-SimpleDeclaration
| | | `-X
| | |-,
| | |-SimpleDeclaration
| | | |-const
| | | |-X
| | | `-SimpleDeclarator
| | | `-&
| | `-)
| `-; | `-;
|-}
`-;
)txt"));
}
TEST_P(SyntaxTreeTest, ClassTemplateDeclaration) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
template<typename T>
struct ST {};
)cpp",
R"txt(
*: TranslationUnit
`-TemplateDeclaration `-TemplateDeclaration
|-template |-template
|-< |-<
|-UnknownDeclaration |-UnknownDeclaration
| |-class | |-typename
| `-T | `-T
|-> |->
`-SimpleDeclaration `-SimpleDeclaration
|-int |-struct
|-ST
|-{
|-}
`-;
)txt"));
}
TEST_P(SyntaxTreeTest, FunctionTemplateDeclaration) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
template<typename T>
T f();
)cpp",
R"txt(
*: TranslationUnit
`-TemplateDeclaration
|-template
|-<
|-UnknownDeclaration
| |-typename
| `-T
|->
`-SimpleDeclaration
|-T
|-SimpleDeclarator |-SimpleDeclarator
| |-fun | |-f
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-;
)txt"));
}
TEST_P(SyntaxTreeTest, VariableTemplateDeclaration) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
template <class T> T var = 10;
gribozavr2Unsubmitted
Done
ReplyInline Actions

I think it should be T var, otherwise T is not used (not using T is valid, but rather unusual).

gribozavr2: I think it should be `T var`, otherwise `T` is not used (not using `T` is valid, but rather…
)cpp",
R"txt(
*: TranslationUnit
`-TemplateDeclaration
|-template
|-<
|-UnknownDeclaration
| |-class
| `-T
|->
`-SimpleDeclaration
|-T
|-SimpleDeclarator
| |-var
| |-=
| `-IntegerLiteralExpression
| `-10
`-;
)txt"));
}
TEST_P(SyntaxTreeTest, StaticMemberFunctionTemplate) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct S {
template<typename U>
static U f();
};
)cpp",
R"txt(
*: TranslationUnit
`-SimpleDeclaration
|-struct
|-S
|-{ |-{
`-} |-TemplateDeclaration
| |-template
| |-<
| |-UnknownDeclaration
| | |-typename
| | `-U
| |->
| `-SimpleDeclaration
| |-static
| |-U
| |-SimpleDeclarator
| | |-f
| | `-ParametersAndQualifiers
| | |-(
| | `-)
| `-;
|-}
`-;
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, NestedTemplates) { TEST_P(SyntaxTreeTest, NestedTemplates) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
Show All 32 Lines `-SimpleDeclaration
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
|-} |-}
`-; `-;
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, NestedComplexDeclaration) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
namespace n {
template<typename T>
struct ST {
template<typename U>
static U f();
};
}
)cpp",
R"txt(
*: TranslationUnit
`-NamespaceDefinition
|-namespace
|-n
|-{
|-TemplateDeclaration
| |-template
| |-<
| |-UnknownDeclaration
| | |-typename
| | `-T
| |->
| `-SimpleDeclaration
| |-struct
| |-ST
| |-{
| |-TemplateDeclaration
| | |-template
| | |-<
| | |-UnknownDeclaration
| | | |-typename
| | | `-U
| | |->
| | `-SimpleDeclaration
| | |-static
| | |-U
| | |-SimpleDeclarator
| | | |-f
| | | `-ParametersAndQualifiers
| | | |-(
| | | `-)
| | `-;
| |-}
| `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, Templates2) { TEST_P(SyntaxTreeTest, Templates2) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( 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 {};
▲ Show 20 Lines • Show All 1,224 Lines • Show Last 20 Lines

clang/unittests/Tooling/Syntax/TreeTestBase.cpp

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 LinesSyntaxTreeTest::treeDumpEqualOnAnnotations(StringRef CodeWithAnnotations,
auto *Root = buildTree(AnnotatedCode.code(), GetParam()); auto *Root = buildTree(AnnotatedCode.code(), GetParam());
if (Diags->getClient()->getNumErrors() != 0) { if (Diags->getClient()->getNumErrors() != 0) {
return ::testing::AssertionFailure() return ::testing::AssertionFailure()
<< "Source file has syntax errors, they were printed to the test " << "Source file has syntax errors, they were printed to the test "
"log"; "log";
} }
bool failed = false; bool Failed = false;
gribozavr2Unsubmitted
Done
ReplyInline Actions
"log";
}
- bool failed = false;
+ bool Failed = false;
auto AnnotatedRanges = AnnotatedCode.ranges();
gribozavr2:
auto AnnotatedRanges = AnnotatedCode.ranges(); auto AnnotatedRanges = AnnotatedCode.ranges();
assert(AnnotatedRanges.size() == TreeDumps.size()); assert(AnnotatedRanges.size() == TreeDumps.size());
gribozavr2Unsubmitted
Done
ReplyInline Actions

ASSERT_EQ I think would be better.

gribozavr2: ASSERT_EQ I think would be better.
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

ASSERT_EQ is a macro that returns void, so we cannot use it here.

However that brings another question.
Right now we have methods treeDumpEqual* that return AssertionResults and we use them in our tests in the following way: EXPECT_TRUE(treeDumpEqual*...).
It seems to me that we should instead perform any assertion inside treeDumpEqual*, and then just call it directly in the test.

WDYT? I case you agree we can perform this change in another patch.

eduucaldas: `ASSERT_EQ` is a macro that returns void, so we cannot use it here. However that brings…
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

We need the EXPECT_TRUE at the test site to get information about in which line number we failed

eduucaldas: We need the `EXPECT_TRUE` at the test site to get information about in which line number we…
for (auto i = 0ul; i < AnnotatedRanges.size(); i++) { for (unsigned i = 0; i < AnnotatedRanges.size(); i++) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

LLVM style is usually:

unsigned i = 0; ...

gribozavr2: LLVM style is usually: unsigned i = 0; ...
auto *AnnotatedNode = nodeByRange(AnnotatedRanges[i], Root); auto *AnnotatedNode = nodeByRange(AnnotatedRanges[i], Root);
assert(AnnotatedNode); assert(AnnotatedNode);
auto AnnotatedNodeDump = auto AnnotatedNodeDump =
std::string(StringRef(AnnotatedNode->dump(*Arena)).trim()); std::string(StringRef(AnnotatedNode->dump(*Arena)).trim());
// EXPECT_EQ shows the diff between the two strings if they are different. // EXPECT_EQ shows the diff between the two strings if they are different.
EXPECT_EQ(TreeDumps[i].trim().str(), AnnotatedNodeDump); EXPECT_EQ(TreeDumps[i].trim().str(), AnnotatedNodeDump)
gribozavr2Unsubmitted
Done
ReplyInline Actions

Could you dump the annotated source code substring to make debugging failing tests easier?

gribozavr2: Could you dump the annotated source code substring to make debugging failing tests easier?
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

Very good suggestion :) thanks

eduucaldas: Very good suggestion :) thanks
<< "Dumps diverged for the code:\n"
<< AnnotatedCode.code().slice(AnnotatedRanges[i].Begin,
AnnotatedRanges[i].End);
if (AnnotatedNodeDump != TreeDumps[i].trim().str()) if (AnnotatedNodeDump != TreeDumps[i].trim().str())
failed = true; Failed = true;
} }
return failed ? ::testing::AssertionFailure() : ::testing::AssertionSuccess(); return Failed ? ::testing::AssertionFailure() : ::testing::AssertionSuccess();
} }
syntax::Node *SyntaxTreeTest::nodeByRange(llvm::Annotations::Range R, syntax::Node *SyntaxTreeTest::nodeByRange(llvm::Annotations::Range R,
syntax::Node *Root) { syntax::Node *Root) {
ArrayRef<syntax::Token> Toks = tokens(Root); ArrayRef<syntax::Token> Toks = tokens(Root);
if (Toks.front().location().isFileID() && Toks.back().location().isFileID() && if (Toks.front().location().isFileID() && Toks.back().location().isFileID() &&
syntax::Token::range(*SourceMgr, Toks.front(), Toks.back()) == syntax::Token::range(*SourceMgr, Toks.front(), Toks.back()) ==
syntax::FileRange(SourceMgr->getMainFileID(), R.Begin, R.End)) syntax::FileRange(SourceMgr->getMainFileID(), R.Begin, R.End))
return Root; return Root;
Show All 10 Lines