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 ↗(On Diff #285629)
199 ↗(On Diff #285629)

ASSERT_EQ I think would be better.

200 ↗(On Diff #285629)

LLVM style is usually:

unsigned i = 0; ...

206 ↗(On Diff #285629)

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
1034

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.

1285

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).

2744

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 ↗(On Diff #285629)

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 ↗(On Diff #285629)

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 ↗(On Diff #285629)

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/
3354 lines

Diff 285612

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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(treeDumpEqual(
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 *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
▲ Show 20 Lines • Show All 165 Lines • ▼ Show 20 Lines `-CompoundStatement
`-} `-}
)txt")); )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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
UnknownExpression
|-UnknownExpression
| |-IdExpression
| | `-UnqualifiedId
| | `-x
| |-.
| `-~
|-decltype
|-(
|-x
|-)
|-(
`-)
)txt"}));
}
TEST_P(SyntaxTreeTest, ClassTemplateDeclaration) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
template<typename T>
struct ST {};
)cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration `-TemplateDeclaration
| |-struct |-template
| |-X |-<
| |-{ |-UnknownDeclaration
| |-} | |-typename
| `-; | `-T
|->
`-SimpleDeclaration `-SimpleDeclaration
|-void |-struct
|-SimpleDeclarator |-ST
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| `-)
`-CompoundStatement
|-{ |-{
|-ExpressionStatement |-}
| |-UnknownExpression `-;
| | |-UnknownExpression
| | | |-IdExpression
| | | | `-UnqualifiedId
| | | | `-x
| | | |-.
| | | `-~
| | |-decltype
| | |-(
| | |-x
| | |-)
| | |-(
| | `-)
| `-;
`-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedId_TemplateId) { TEST_P(SyntaxTreeTest, FunctionTemplateDeclaration) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
template<typename T> template<typename T>
T f(); T f();
void test() {
f<int>();
}
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-TemplateDeclaration `-TemplateDeclaration
| |-template |-template
| |-< |-<
| |-UnknownDeclaration |-UnknownDeclaration
| | |-typename | |-typename
| | `-T | `-T
| |-> |->
| `-SimpleDeclaration
| |-T
| |-SimpleDeclarator
| | |-f
| | `-ParametersAndQualifiers
| | |-(
| | `-)
| `-;
`-SimpleDeclaration `-SimpleDeclaration
|-void |-T
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-f
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-;
|-{
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | |-f
| | | |-<
| | | |-int
| | | `->
| | |-(
| | `-)
| `-;
`-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedId_TemplateId) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqualOnAnnotations(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
R"cpp(
template<typename T>
T f();
void test() {
[[f<int>()]];
}
)cpp",
{R"txt(
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(treeDumpEqual(
R"cpp( R"cpp(
namespace n { namespace n {
struct S { }; struct S { };
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines `-CompoundStatement
`-} `-}
)txt")); )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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
SimpleDeclaration
|-NestedNameSpecifier
| |-::
| |-SimpleTemplateNameSpecifier
| | |-ST
| | |-<
| | |-int
| | `->
| `-::
|-S
`-SimpleDeclarator
`-UnknownExpression
`-s2
)txt"}));
}
TEST_P(SyntaxTreeTest, StaticMemberFunction) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct S {
static void f(){}
};
)cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-TemplateDeclaration
| |-template
| |-<
| |-UnknownDeclaration
| | |-typename
| | `-T
| |->
| `-SimpleDeclaration
| |-struct
| |-ST
| |-{
| |-SimpleDeclaration
| | |-struct
| | |-S
| | |-{
| | |-}
| | `-;
| |-}
| `-;
`-SimpleDeclaration `-SimpleDeclaration
|-void |-struct
|-SimpleDeclarator |-S
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{ |-{
|-DeclarationStatement |-SimpleDeclaration
| |-SimpleDeclaration | |-static
| | |-NestedNameSpecifier | |-void
| | | |-:: | |-SimpleDeclarator
| | | |-SimpleTemplateNameSpecifier | | |-f
| | | | |-template | | `-ParametersAndQualifiers
| | | | |-ST | | |-(
| | | | |-< | | `-)
| | | | |-int | `-CompoundStatement
| | | | `-> | |-{
| | | `-:: | `-}
| | |-S |-}
| | `-SimpleDeclarator `-;
| | `-UnknownExpression
| | `-s1
| `-;
|-DeclarationStatement
| |-SimpleDeclaration
| | |-NestedNameSpecifier
| | | |-::
| | | |-SimpleTemplateNameSpecifier
| | | | |-ST
| | | | |-<
| | | | |-int
| | | | `->
| | | `-::
| | |-S
| | `-SimpleDeclarator
| | `-UnknownExpression
| | `-s2
| `-;
`-}
)txt")); )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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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
| |-} |-(
| `-; `-)
)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 `-SimpleDeclaration
|-void |-struct
|-SimpleDeclarator |-S
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-S
| | `-SimpleDeclarator
| | `-s
| `-)
`-CompoundStatement
|-{ |-{
|-ExpressionStatement |-TemplateDeclaration
| |-UnknownExpression | |-template
| | |-IdExpression | |-<
| | | |-NestedNameSpecifier | |-UnknownDeclaration
| | | | |-DecltypeNameSpecifier | | |-typename
| | | | | |-decltype | | `-U
| | | | | |-( | |->
| | | | | |-IdExpression | `-SimpleDeclaration
| | | | | | `-UnqualifiedId | |-static
| | | | | | `-s | |-U
| | | | | `-) | |-SimpleDeclarator
| | | | `-:: | | |-f
| | | `-UnqualifiedId | | `-ParametersAndQualifiers
| | | `-f
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
`-} |-}
`-;
)txt")); )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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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",
{R"txt(
UnknownExpression
|-IdExpression
| |-NestedNameSpecifier
| | |-IdentifierNameSpecifier
| | | `-S
| | `-::
| `-UnqualifiedId
| |-f
| |-<
| |-int
| `->
|-(
`-)
)txt",
R"txt(
UnknownExpression
|-IdExpression
| |-NestedNameSpecifier
| | |-IdentifierNameSpecifier
| | | `-S
| | `-::
| |-template
| `-UnqualifiedId
| |-f
| |-<
| |-int
| `->
|-(
`-)
)txt"}));
}
TEST_P(SyntaxTreeTest, QualifiedId_Complex_Declaration) {
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…
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
namespace n {
template<typename T>
struct ST {
template<typename U>
static U f();
};
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration `-NamespaceDefinition
|-namespace
|-n
|-{
|-TemplateDeclaration
| |-template
| |-<
| |-UnknownDeclaration
| | |-typename
| | `-T
| |->
| `-SimpleDeclaration
| |-struct | |-struct
| |-S | |-ST
| |-{ | |-{
| |-TemplateDeclaration | |-TemplateDeclaration
| | |-template | | |-template
| | |-< | | |-<
| | |-UnknownDeclaration | | |-UnknownDeclaration
| | | |-typename | | | |-typename
| | | `-U | | | `-U
| | |-> | | |->
| | `-SimpleDeclaration | | `-SimpleDeclaration
| | |-static | | |-static
| | |-U | | |-U
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-f | | | |-f
| | | `-ParametersAndQualifiers | | | `-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")); )txt"));
} }
TEST_P(SyntaxTreeTest, QualifiedId_Complex) { TEST_P(SyntaxTreeTest, QualifiedId_Complex) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
ParenExpression
|-(
|-ParenExpression
| |-(
| |-IntegerLiteralExpression
| | `-1
| `-)
`-)
)txt",
R"txt(
ParenExpression
|-(
|-BinaryOperatorExpression
| |-IntegerLiteralExpression
| | `-1
| |-+
| `-ParenExpression
| |-(
| |-IntegerLiteralExpression
| | `-2
| `-)
`-)
)txt"}));
}
TEST_P(SyntaxTreeTest, UserDefinedLiteral_LiteralOperatorDeclaration) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
unsigned operator "" _c(char);
)cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-unsigned
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-operator
| |-""
| |-_c
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-SimpleDeclaration
| | `-char
| `-) | `-)
`-CompoundStatement `-;
|-{
|-ExpressionStatement
| |-ParenExpression
| | |-(
| | |-IntegerLiteralExpression
| | | `-1
| | `-)
| `-;
|-ExpressionStatement
| |-ParenExpression
| | |-(
| | |-ParenExpression
| | | |-(
| | | |-IntegerLiteralExpression
| | | | `-1
| | | `-)
| | `-)
| `-;
|-ExpressionStatement
| |-ParenExpression
| | |-(
| | |-BinaryOperatorExpression
| | | |-IntegerLiteralExpression
| | | | `-1
| | | |-+
| | | `-ParenExpression
| | | |-(
| | | |-IntegerLiteralExpression
| | | | `-2
| | | `-)
| | `-)
| `-;
`-}
)txt")); )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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
R"cpp( R"cpp(
unsigned operator "" _c(char); unsigned operator "" _c(char);
void test() { void test() {
'2'_c; [['2'_c]];
} }
)cpp", )cpp",
{R"txt(
CharUserDefinedLiteralExpression
`-'2'_c
)txt"}));
}
TEST_P(SyntaxTreeTest, UserDefinedLiteral_Typedef) {
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…
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
typedef decltype(sizeof(void *)) size_t;
)cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_c
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | `-char
| | `-)
| `-;
`-SimpleDeclaration `-SimpleDeclaration
|-void |-typedef
|-SimpleDeclarator |-decltype
| |-test |-(
| `-ParametersAndQualifiers |-UnknownExpression
| |-sizeof
| |-( | |-(
| |-void
| |-*
| `-) | `-)
`-CompoundStatement |-)
|-{ |-SimpleDeclarator
|-ExpressionStatement | `-size_t
| |-CharUserDefinedLiteralExpression `-;
| | `-'2'_c
| `-;
`-}
)txt")); )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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
StringUserDefinedLiteralExpression
`-"12"_s
)txt"}));
}
TEST_P(SyntaxTreeTest,
UserDefinedLiteral_NumericLiteralOperatorTemplateDeclaration) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
template <char...>
unsigned operator "" _t();
)cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-TemplateDeclaration
|-template
|-<
|-SimpleDeclaration |-SimpleDeclaration
| |-typedef | `-char
| |-decltype |-...
| |-( |->
| |-UnknownExpression
| | |-sizeof
| | |-(
| | |-void
| | |-*
| | `-)
| |-)
| |-SimpleDeclarator
| | `-size_t
| `-;
|-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_s
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | |-const
| | | |-char
| | | `-SimpleDeclarator
| | | `-*
| | |-,
| | |-SimpleDeclaration
| | | `-size_t
| | `-)
| `-;
`-SimpleDeclaration `-SimpleDeclaration
|-void |-unsigned
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-operator
| |-""
| |-_t
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-;
|-{
|-ExpressionStatement
| |-StringUserDefinedLiteralExpression
| | `-"12"_s
| `-;
`-}
)txt")); )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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'treeDumpEqualOnAnnotations' [clang-diagnostic…
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(
BinaryOperatorExpression
|-BinaryOperatorExpression
| |-IntegerLiteralExpression
| | `-1
| |-%
| `-IntegerLiteralExpression
| `-2
|-+
`-BinaryOperatorExpression
|-IntegerLiteralExpression
| `-3
|-*
`-IntegerLiteralExpression
`-4
)txt"}));
}
TEST_P(SyntaxTreeTest, OverloadedOperator_MemberDeclaration) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
X& operator=(const X&);
};
)cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-struct
|-SimpleDeclarator |-X
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{ |-{
|-ExpressionStatement |-SimpleDeclaration
| |-BinaryOperatorExpression | |-X
| | |-BinaryOperatorExpression | |-SimpleDeclarator
| | | |-IntegerLiteralExpression | | |-&
| | | | `-1 | | |-operator
| | | |-+ | | |-=
| | | `-BinaryOperatorExpression | | `-ParametersAndQualifiers
| | | |-IntegerLiteralExpression | | |-(
| | | | `-2 | | |-SimpleDeclaration
| | | |-* | | | |-const
| | | `-IntegerLiteralExpression | | | |-X
| | | `-3 | | | `-SimpleDeclarator
| | |-+ | | | `-&
| | `-IntegerLiteralExpression | | `-)
| | `-4
| `-;
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-BinaryOperatorExpression
| | | |-IntegerLiteralExpression
| | | | `-1
| | | |-%
| | | `-IntegerLiteralExpression
| | | `-2
| | |-+
| | `-BinaryOperatorExpression
| | |-IntegerLiteralExpression
| | | `-3
| | |-*
| | `-IntegerLiteralExpression
| | `-4
| `-; | `-;
`-} |-}
`-;
)txt")); )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(
BinaryOperatorExpression
|-IdExpression
| `-UnqualifiedId
| `-x
|-=
`-IdExpression
`-UnqualifiedId
`-y
)txt"}));
}
TEST_P(SyntaxTreeTest, OverloadedOperator_FriendDeclarataion) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
friend X operator+(X, const X&);
};
)cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-SimpleDeclaration
| | |-X
| | |-SimpleDeclarator
| | | |-&
| | | |-operator
| | | |-=
| | | `-ParametersAndQualifiers
| | | |-(
| | | |-SimpleDeclaration
| | | | |-const
| | | | |-X
| | | | `-SimpleDeclarator
| | | | `-&
| | | `-)
| | `-;
| |-}
| `-;
`-SimpleDeclaration `-SimpleDeclaration
|-void |-struct
|-SimpleDeclarator |-X
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| |-,
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-y
| `-)
`-CompoundStatement
|-{ |-{
|-ExpressionStatement |-UnknownDeclaration
| |-BinaryOperatorExpression | `-SimpleDeclaration
| | |-IdExpression | |-friend
| | | `-UnqualifiedId | |-X
| | | `-x | |-SimpleDeclarator
| | |-= | | |-operator
| | `-IdExpression | | |-+
| | `-UnqualifiedId | | `-ParametersAndQualifiers
| | `-y | | |-(
| | |-SimpleDeclaration
| | | `-X
| | |-,
| | |-SimpleDeclaration
| | | |-const
| | | |-X
| | | `-SimpleDeclarator
| | | `-&
| | `-)
| `-; | `-;
`-} |-}
`-;
)txt")); )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 303 Lines • ▼ Show 20 Lines
} }
TEST_P(SyntaxTreeTest, NestedTemplates) { TEST_P(SyntaxTreeTest, NestedTemplates) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
template <class T> template <class T>
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…
struct X { struct X {
template <class U> template <class U>
U foo(); U foo();
}; };
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-TemplateDeclaration `-TemplateDeclaration
▲ Show 20 Lines • Show All 1,262 Lines • Show Last 20 Lines