This is an archive of the discontinued LLVM Phabricator instance.

Differential D85819

[SyntaxTree] Split tests
ClosedPublic

Authored by eduucaldas on Aug 12 2020, 1:57 AM.

Details

Reviewers
gribozavr2
Commits
rGd1211fd1ec03: [SyntaxTree] Split tests for expressions
Summary

We do that because:

  • Big tests generated big tree dumps that could hardly serve as documentation.
  • In most cases the tests didn't share setup, thus there was not much addition in lines of code.

Diff Detail

Event Timeline

eduucaldas created this revision.Aug 12 2020, 1:57 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 12 2020, 1:57 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
eduucaldas requested review of this revision.Aug 12 2020, 1:57 AM
eduucaldas added a comment.Aug 12 2020, 2:14 AM

Before we had an UnqualifiedId test that tested for everything in the grammar. Now we just split this test and test the alternatives separately.

clang/unittests/Tooling/Syntax/TreeTest.cpp
635–666

It seems inappropriate to always repeat UnqualfiiedId, do you have any other suggestion?

eduucaldas added a reviewer: gribozavr2.Aug 12 2020, 2:14 AM
Harbormaster completed remote builds in B68076: Diff 285011.Aug 12 2020, 2:46 AM
eduucaldas updated this revision to Diff 285035.Aug 12 2020, 4:24 AM

Split tests for UserDefinedLiteral
Split tests for NumericUserDefinedLiteral
Split tests for NestedBinaryOperator
Split tests for UserDefinedBinaryOperator
Split tests for UserDefinedPrefixOperator

Harbormaster completed remote builds in B68089: Diff 285035.Aug 12 2020, 4:53 AM
eduucaldas updated this revision to Diff 285070.Aug 12 2020, 6:53 AM
  • [SyntaxTree] Split tests for QualifiedId
eduucaldas updated this revision to Diff 285071.Aug 12 2020, 6:54 AM

Rename tests following TestSuite_TestCase

eduucaldas added inline comments.Aug 12 2020, 7:03 AM
clang/unittests/Tooling/Syntax/TreeTest.cpp
635–666

Last commit change names to TestSuite_TestCase

1005

Here I didn't merely split the tests, I also changed them a bit. PTAL.

1712–1714

Same setup for FloatUserDefinedLiteral. I think it is justified with the Annotations we can constraint the dump just to the expressions being tested

Harbormaster completed remote builds in B68105: Diff 285070.Aug 12 2020, 7:22 AM
Harbormaster completed remote builds in B68106: Diff 285071.Aug 12 2020, 7:26 AM
gribozavr2 accepted this revision.Aug 12 2020, 3:47 PM

Please also consider splitting the file into multiple.

clang/unittests/Tooling/Syntax/TreeTest.cpp
1238

Indent -2.

1412

For consistency with other test names: QualifiedId_DecltypeSpecifier

2646

BinaryOperator_NestedWithParenthesis

2690

BinaryOperator_Associativity

2750

BinaryOperator_Precedence

2805

UserDefinedOperator => OverloadedOperator?

"user-defined" seems to suggest that the operator was previously not a thing in C++.

3021

UserDefinedOperator_LeftShift

3161

UserDefinedOperator_PointerToMember

3230

PrefixIncrement

3284

UserDefinedOperator_Negation

3393

PostfixIncrement

Also, group it right after prefix increment?

This revision is now accepted and ready to land.Aug 12 2020, 3:47 PM
eduucaldas updated this revision to Diff 285273.Aug 13 2020, 12:34 AM
eduucaldas marked 11 inline comments as done.

Answer review comments

clang/unittests/Tooling/Syntax/TreeTest.cpp
2805

Actually it is a very good point! Thanks!

3393

I'm grouping together Prefix operators. But you're right it makes sense to put them close to each other. I've put PrefixIncrement as the last Prefix operator to achieve that

Harbormaster completed remote builds in B68222: Diff 285273.Aug 13 2020, 12:34 AM
eduucaldas added inline comments.Aug 13 2020, 12:57 AM
clang/unittests/Tooling/Syntax/TreeTest.cpp
1712–1714

Taking account the Annotations change. Duplicating two lines of code between tests should be ok.

eduucaldas added a comment.Aug 13 2020, 12:57 AM

We'll split this file in a future change

This revision was landed with ongoing or failed builds.Aug 13 2020, 1:18 AM
Closed by commit rGd1211fd1ec03: [SyntaxTree] Split tests for expressions (authored by eduucaldas). · Explain Why
This revision was automatically updated to reflect the committed changes.
eduucaldas added a commit: rGd1211fd1ec03: [SyntaxTree] Split tests for expressions.

Revision Contents

PathSize
clang/
unittests/
Tooling/
Syntax/
1485 lines

Diff 285278

clang/unittests/Tooling/Syntax/TreeTest.cpp

Show First 20 Lines • Show All 626 Lines • ▼ Show 20 Lines `-CompoundStatement
| | | `-test | | | `-test
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedId) { TEST_P(SyntaxTreeTest, UnqualifiedIdIdentifier) {
EXPECT_TRUE(treeDumpEqual(
R"cpp(
void test(int a) {
a;
}
)cpp",
R"txt(
*: TranslationUnit
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | `-a
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-IdExpression
| | `-UnqualifiedId
| | `-a
| `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, UnqualifiedIdOperatorFunctionId) {
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

It seems inappropriate to always repeat UnqualfiiedId, do you have any other suggestion?

eduucaldas: It seems inappropriate to always repeat `UnqualfiiedId`, do you have any other suggestion?
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

Last commit change names to TestSuite_TestCase

eduucaldas: Last commit change names to `TestSuite_TestCase`
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
struct X { struct X {
// TODO: Expose `id-expression` from `Declarator`
friend X operator+(const X&, const X&); friend X operator+(const X&, const X&);
operator int();
}; };
template<typename T>
void f(T&);
void test(X x) { void test(X x) {
x; // identifier operator+(x, x);
operator+(x, x); // operator-function-id
f<X>(x); // template-id
// TODO: Expose `id-expression` from `MemberExpr`
x.operator int(); // conversion-funtion-id
x.~X(); // ~type-name
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-struct | |-struct
| |-X | |-X
| |-{ | |-{
Show All 14 Lines
| | | |-, | | | |-,
| | | |-SimpleDeclaration | | | |-SimpleDeclaration
| | | | |-const | | | | |-const
| | | | |-X | | | | |-X
| | | | `-SimpleDeclarator | | | | `-SimpleDeclarator
| | | | `-& | | | | `-&
| | | `-) | | | `-)
| | `-; | | `-;
| |-SimpleDeclaration
| | |-SimpleDeclarator
| | | |-operator
| | | |-int
| | | `-ParametersAndQualifiers
| | | |-(
| | | `-)
| | `-;
| |-} | |-}
| `-; | `-;
|-TemplateDeclaration
| |-template
| |-<
| |-UnknownDeclaration
| | |-typename
| | `-T
| |->
| `-SimpleDeclaration
| |-void
| |-SimpleDeclarator
| | |-f
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | |-T
| | | `-SimpleDeclarator
| | | `-&
| | `-)
| `-;
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-X | | |-X
| | `-SimpleDeclarator | | `-SimpleDeclarator
| | `-x | | `-x
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-ExpressionStatement |-ExpressionStatement
| |-IdExpression
| | `-UnqualifiedId
| | `-x
| `-;
|-ExpressionStatement
| |-UnknownExpression | |-UnknownExpression
| | |-IdExpression | | |-IdExpression
| | | `-UnqualifiedId | | | `-UnqualifiedId
| | | |-operator | | | |-operator
| | | `-+ | | | `-+
| | |-( | | |-(
| | |-IdExpression | | |-IdExpression
| | | `-UnqualifiedId | | | `-UnqualifiedId
| | | `-x | | | `-x
| | |-, | | |-,
| | |-IdExpression | | |-IdExpression
| | | `-UnqualifiedId | | | `-UnqualifiedId
| | | `-x | | | `-x
| | `-) | | `-)
| `-; | `-;
|-ExpressionStatement `-}
| |-UnknownExpression )txt"));
| | |-IdExpression }
| | | `-UnqualifiedId
| | | |-f TEST_P(SyntaxTreeTest, UnqualifiedIdConversionFunctionId) {
| | | |-< if (!GetParam().isCXX()) {
| | | |-X return;
| | | `-> }
| | |-( EXPECT_TRUE(treeDumpEqual(
| | |-IdExpression R"cpp(
| | | `-UnqualifiedId struct X {
| | | `-x operator int();
| | `-) };
void test(X x) {
// TODO: Expose `id-expression` from `MemberExpr`
x.operator int();
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-SimpleDeclaration
| | |-SimpleDeclarator
| | | |-operator
| | | |-int
| | | `-ParametersAndQualifiers
| | | |-(
| | | `-)
| | `-;
| |-}
| `-; | `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement |-ExpressionStatement
| |-UnknownExpression | |-UnknownExpression
| | |-UnknownExpression | | |-UnknownExpression
| | | |-IdExpression | | | |-IdExpression
| | | | `-UnqualifiedId | | | | `-UnqualifiedId
| | | | `-x | | | | `-x
| | | |-. | | | |-.
| | | |-operator | | | |-operator
| | | `-int | | | `-int
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, UnqualifiedIdLiteralOperatorId) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
unsigned operator "" _w(char);
void test() {
operator "" _w('1');
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_w
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | `-char
| | `-)
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | |-operator
| | | |-""
| | | `-_w
| | |-(
| | |-CharacterLiteralExpression
| | | `-'1'
| | `-)
| `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, UnqualifiedIdDestructor) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X { };
void test(X x) {
// TODO: Expose `id-expression` from `MemberExpr`
x.~X();
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement |-ExpressionStatement
| |-UnknownExpression | |-UnknownExpression
| | |-UnknownExpression | | |-UnknownExpression
| | | |-IdExpression | | | |-IdExpression
| | | | `-UnqualifiedId | | | | `-UnqualifiedId
| | | | `-x | | | | `-x
| | | |-. | | | |-.
| | | |-~ | | | |-~
| | | `-X | | | `-X
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, UnqualifiedIdCxx11OrLater) { TEST_P(SyntaxTreeTest, UnqualifiedIdDecltypeDestructor) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
struct X { }; struct X { };
unsigned operator "" _w(long long unsigned);
void test(X x) { void test(X x) {
operator "" _w(1llu); // literal-operator-id
// TODO: Expose `id-expression` from `MemberExpr` // TODO: Expose `id-expression` from `MemberExpr`
x.~decltype(x)(); // ~decltype-specifier x.~decltype(x)();
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-struct | |-struct
| |-X | |-X
| |-{ | |-{
| |-} | |-}
| `-; | `-;
|-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_w
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | |-long
| | | |-long
| | | `-unsigned
| | `-)
| `-;
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-X | | |-X
| | `-SimpleDeclarator | | `-SimpleDeclarator
| | `-x | | `-x
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-ExpressionStatement |-ExpressionStatement
| |-UnknownExpression | |-UnknownExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | |-operator
| | | |-""
| | | `-_w
| | |-(
| | |-IntegerLiteralExpression
| | | `-1llu
| | `-)
| `-;
|-ExpressionStatement
| |-UnknownExpression
| | |-UnknownExpression | | |-UnknownExpression
| | | |-IdExpression | | | |-IdExpression
| | | | `-UnqualifiedId | | | | `-UnqualifiedId
| | | | `-x | | | | `-x
| | | |-. | | | |-.
| | | `-~ | | | `-~
| | |-decltype | | |-decltype
| | |-( | | |-(
| | |-x | | |-x
| | |-) | | |-)
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, QualifiedId) { TEST_P(SyntaxTreeTest, UnqualifiedIdTemplateId) {
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
namespace n {
struct S {
template<typename T> template<typename T>
struct ST { T f();
static void f();
};
};
}
template<typename T>
struct ST {
struct S {
template<typename U>
static U f();
};
};
void test() { void test() {
:: // global-namespace-specifier
n:: // namespace-specifier
S:: // type-name-specifier
template ST<int>:: // type-template-instantiation-specifier
f();
n:: // namespace-specifier
S:: // type-name-specifier
ST<int>:: // type-template-instantiation-specifier
f();
ST<int>:: // type-name-specifier
S:: // type-name-specifier
f<int>(); f<int>();
}
)cpp",
R"txt(
*: TranslationUnit
|-TemplateDeclaration
| |-template
| |-<
| |-UnknownDeclaration
| | |-typename
| | `-T
| |->
| `-SimpleDeclaration
| |-T
| |-SimpleDeclarator
| | |-f
| | `-ParametersAndQualifiers
| | |-(
| | `-)
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-UnknownExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | |-f
| | | |-<
| | | |-int
| | | `->
| | |-(
| | `-)
| `-;
`-}
)txt"));
}
ST<int>:: // type-name-specifier TEST_P(SyntaxTreeTest, QualifiedIdWithNamespace) {
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

Here I didn't merely split the tests, I also changed them a bit. PTAL.

eduucaldas: Here I didn't merely split the tests, I also changed them a bit. PTAL.
S:: // type-name-specifier if (!GetParam().isCXX()) {
template f<int>(); return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
namespace n {
struct S { };
}
void test() {
::n::S s1;
n::S s2;
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-NamespaceDefinition |-NamespaceDefinition
| |-namespace | |-namespace
| |-n | |-n
| |-{ | |-{
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-struct | | |-struct
| | |-S | | |-S
| | |-{ | | |-{
| | |-TemplateDeclaration
| | | |-template
| | | |-<
| | | |-UnknownDeclaration
| | | | |-typename
| | | | `-T
| | | |->
| | | `-SimpleDeclaration
| | | |-struct
| | | |-ST
| | | |-{
| | | |-SimpleDeclaration
| | | | |-static
| | | | |-void
| | | | |-SimpleDeclarator
| | | | | |-f
| | | | | `-ParametersAndQualifiers
| | | | | |-(
| | | | | `-)
| | | | `-;
| | | |-}
| | | `-;
| | |-} | | |-}
| | `-; | | `-;
| `-} | `-}
`-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, QualifiedIdWithTemplateSpecifier) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
template<typename T>
struct ST {
struct S { };
};
void test() {
::template ST<int>::S s1;
::ST<int>::S s2;
}
)cpp",
R"txt(
*: TranslationUnit
|-TemplateDeclaration |-TemplateDeclaration
| |-template | |-template
| |-< | |-<
| |-UnknownDeclaration | |-UnknownDeclaration
| | |-typename | | |-typename
| | `-T | | `-T
| |-> | |->
| `-SimpleDeclaration | `-SimpleDeclaration
| |-struct | |-struct
| |-ST | |-ST
| |-{ | |-{
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-struct | | |-struct
| | |-S | | |-S
| | |-{ | | |-{
| | |-TemplateDeclaration
| | | |-template
| | | |-<
| | | |-UnknownDeclaration
| | | | |-typename
| | | | `-U
| | | |->
| | | `-SimpleDeclaration
| | | |-static
| | | |-U
| | | |-SimpleDeclarator
| | | | |-f
| | | | `-ParametersAndQualifiers
| | | | |-(
| | | | `-)
| | | `-;
| | |-} | | |-}
| | `-; | | `-;
| |-} | |-}
| `-; | `-;
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-ExpressionStatement |-DeclarationStatement
| |-UnknownExpression | |-SimpleDeclaration
| | |-IdExpression | | |-NestedNameSpecifier
| | | |-NestedNameSpecifier | | | |-::
| | | | |-:: | | | |-SimpleTemplateNameSpecifier
| | | | |-IdentifierNameSpecifier | | | | |-template
| | | | | `-n | | | | |-ST
| | | | |-:: | | | | |-<
| | | | |-IdentifierNameSpecifier | | | | |-int
| | | | | `-S | | | | `->
| | | | |-:: | | | `-::
| | | | |-SimpleTemplateNameSpecifier | | |-S
| | | | | |-template | | `-SimpleDeclarator
| | | | | |-ST | | `-UnknownExpression
| | | | | |-< | | `-s1
| | | | | |-int | `-;
| | | | | `-> |-DeclarationStatement
| | | | `-:: | |-SimpleDeclaration
| | | `-UnqualifiedId | | |-NestedNameSpecifier
| | | `-f | | | |-::
| | |-( | | | |-SimpleTemplateNameSpecifier
| | `-) | | | | |-ST
| | | | |-<
| | | | |-int
| | | | `->
| | | `-::
| | |-S
| | `-SimpleDeclarator
| | `-UnknownExpression
| | `-s2
| `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, QualifiedIdWithOptionalTemplateKw) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct S {
template<typename U>
static U f();
};
void test() {
S::f<int>();
S::template f<int>();
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-S
| |-{
| |-TemplateDeclaration
| | |-template
| | |-<
| | |-UnknownDeclaration
| | | |-typename
| | | `-U
| | |->
| | `-SimpleDeclaration
| | |-static
| | |-U
| | |-SimpleDeclarator
| | | |-f
| | | `-ParametersAndQualifiers
| | | |-(
| | | `-)
| | `-;
| |-}
| `-; | `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement |-ExpressionStatement
| |-UnknownExpression | |-UnknownExpression
| | |-IdExpression | | |-IdExpression
| | | |-NestedNameSpecifier | | | |-NestedNameSpecifier
| | | | |-IdentifierNameSpecifier | | | | |-IdentifierNameSpecifier
| | | | | `-n
| | | | |-::
| | | | |-IdentifierNameSpecifier
| | | | | `-S | | | | | `-S
| | | | |-::
| | | | |-SimpleTemplateNameSpecifier
| | | | | |-ST
| | | | | |-<
| | | | | |-int
| | | | | `->
| | | | `-:: | | | | `-::
| | | `-UnqualifiedId | | | `-UnqualifiedId
| | | `-f | | | |-f
| | | |-<
| | | |-int
| | | `->
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
|-ExpressionStatement |-ExpressionStatement
| |-UnknownExpression | |-UnknownExpression
| | |-IdExpression | | |-IdExpression
| | | |-NestedNameSpecifier | | | |-NestedNameSpecifier
| | | | |-SimpleTemplateNameSpecifier
| | | | | |-ST
| | | | | |-<
| | | | | |-int
| | | | | `->
| | | | |-::
| | | | |-IdentifierNameSpecifier | | | | |-IdentifierNameSpecifier
| | | | | `-S | | | | | `-S
| | | | `-:: | | | | `-::
| | | |-template
| | | `-UnqualifiedId | | | `-UnqualifiedId
| | | |-f | | | |-f
| | | |-< | | | |-<
| | | |-int | | | |-int
| | | `-> | | | `->
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, QualifiedIdComplex) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
namespace n {
template<typename T>
gribozavr2Unsubmitted
Done
ReplyInline Actions

Indent -2.

gribozavr2: Indent -2.
struct ST {
template<typename U>
static U f();
};
}
void test() {
::n::template ST<int>::template f<int>();
}
)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
| | | | |-(
| | | | `-)
| | | `-;
| | |-}
| | `-;
| `-}
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement |-ExpressionStatement
| |-UnknownExpression | |-UnknownExpression
| | |-IdExpression | | |-IdExpression
| | | |-NestedNameSpecifier | | | |-NestedNameSpecifier
| | | | |-::
| | | | |-IdentifierNameSpecifier
| | | | | `-n
| | | | |-::
| | | | |-SimpleTemplateNameSpecifier | | | | |-SimpleTemplateNameSpecifier
| | | | | |-template
| | | | | |-ST | | | | | |-ST
| | | | | |-< | | | | | |-<
| | | | | |-int | | | | | |-int
| | | | | `-> | | | | | `->
| | | | |-::
| | | | |-IdentifierNameSpecifier
| | | | | `-S
| | | | `-:: | | | | `-::
| | | |-template | | | |-template
| | | `-UnqualifiedId | | | `-UnqualifiedId
| | | |-f | | | |-f
| | | |-< | | | |-<
| | | |-int | | | |-int
| | | `-> | | | `->
| | |-( | | |-(
Show All 12 Lines if (GetParam().hasDelayedTemplateParsing()) {
// tree when `-fdelayed-template-parsing` is active. // tree when `-fdelayed-template-parsing` is active.
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
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 *: TranslationUnit
`-TemplateDeclaration `-TemplateDeclaration
|-template |-template
|-< |-<
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines `-CompoundStatement
| | | `-> | | | `->
| | |-( | | |-(
| | `-) | | `-)
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, QualifiedIdDecltype) { TEST_P(SyntaxTreeTest, QualifiedIdDecltype) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

For consistency with other test names: QualifiedId_DecltypeSpecifier

gribozavr2: For consistency with other test names: `QualifiedId_DecltypeSpecifier`
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
struct S { struct S {
static void f(){} static void f(){}
}; };
void test(S s) { void test(S s) {
decltype(s):: // decltype-specifier decltype(s)::f();
f();
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-struct | |-struct
| |-S | |-S
| |-{ | |-{
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines `-CompoundStatement
| | | | `-2 | | | | `-2
| | | `-) | | | `-)
| | `-) | | `-)
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, UserDefinedLiteral) { TEST_P(SyntaxTreeTest, CharUserDefinedLiteral) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
unsigned operator "" _c(char);
void test() {
'2'_c;
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_c
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | `-char
| | `-)
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-CharUserDefinedLiteralExpression
| | `-'2'_c
| `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, StringUserDefinedLiteral) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
typedef decltype(sizeof(void *)) size_t; typedef decltype(sizeof(void *)) size_t;
unsigned operator "" _i(unsigned long long);
unsigned operator "" _f(long double);
unsigned operator "" _c(char);
unsigned operator "" _s(const char*, size_t); unsigned operator "" _s(const char*, size_t);
unsigned operator "" _r(const char*);
template <char...>
unsigned operator "" _t();
void test() { void test() {
12_i; // call: operator "" _i(12uLL) | kind: integer "12"_s;
1.2_f; // call: operator "" _f(1.2L) | kind: float
'2'_c; // call: operator "" _c('2') | kind: char
"12"_s; // call: operator "" _s("12") | kind: string
12_r; // call: operator "" _r("12") | kind: integer
1.2_r; // call: operator "" _i("1.2") | kind: float
12_t; // call: operator<'1', '2'> "" _x() | kind: integer
1.2_t; // call: operator<'1', '2'> "" _x() | kind: float
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-typedef | |-typedef
| |-decltype | |-decltype
| |-( | |-(
| |-UnknownExpression | |-UnknownExpression
| | |-sizeof | | |-sizeof
| | |-( | | |-(
| | |-void | | |-void
| | |-* | | |-*
| | `-) | | `-)
| |-) | |-)
| |-SimpleDeclarator | |-SimpleDeclarator
| | `-size_t | | `-size_t
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
| |-unsigned | |-unsigned
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-operator | | |-operator
| | |-"" | | |-""
| | |-_s
| | `-ParametersAndQualifiers
| | |-(
| | |-SimpleDeclaration
| | | |-const
| | | |-char
| | | `-SimpleDeclarator
| | | `-*
| | |-,
| | |-SimpleDeclaration
| | | `-size_t
| | `-)
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-StringUserDefinedLiteralExpression
| | `-"12"_s
| `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, IntegerUserDefinedLiteral) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
unsigned operator "" _i(unsigned long long);
unsigned operator "" _r(const char*);
template <char...>
unsigned operator "" _t();
void test() {
12_i;
12_r;
12_t;
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-unsigned
| |-SimpleDeclarator
| | |-operator
| | |-""
| | |-_i | | |-_i
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-SimpleDeclaration | | |-SimpleDeclaration
| | | |-unsigned | | | |-unsigned
| | | |-long | | | |-long
| | | `-long | | | `-long
| | `-) | | `-)
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
| |-unsigned | |-unsigned
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-operator | | |-operator
| | |-"" | | |-""
| | |-_f | | |-_r
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-SimpleDeclaration | | |-SimpleDeclaration
| | | |-long | | | |-const
| | | `-double | | | |-char
| | | `-SimpleDeclarator
| | | `-*
| | `-) | | `-)
| `-; | `-;
|-SimpleDeclaration |-TemplateDeclaration
| |-template
| |-<
| |-SimpleDeclaration
| | `-char
| |-...
| |->
| `-SimpleDeclaration
| |-unsigned | |-unsigned
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-operator | | |-operator
| | |-"" | | |-""
| | |-_c | | |-_t
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-SimpleDeclaration
| | | `-char
| | `-) | | `-)
| `-; | `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

Same setup for FloatUserDefinedLiteral. I think it is justified with the Annotations we can constraint the dump just to the expressions being tested

eduucaldas: Same setup for `FloatUserDefinedLiteral`. I think it is justified with the Annotations we can…
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

Taking account the Annotations change. Duplicating two lines of code between tests should be ok.

eduucaldas: Taking account the Annotations change. Duplicating two lines of code between tests should be ok.
| |-IntegerUserDefinedLiteralExpression
| | `-12_i
| `-;
|-ExpressionStatement
| |-IntegerUserDefinedLiteralExpression
| | `-12_r
| `-;
|-ExpressionStatement
| |-IntegerUserDefinedLiteralExpression
| | `-12_t
| `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, FloatUserDefinedLiteral) {
if (!GetParam().isCXX11OrLater()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
unsigned operator "" _f(long double);
unsigned operator "" _r(const char*);
template <char...>
unsigned operator "" _t();
void test() {
1.2_f; // call: operator "" _f(1.2L) | kind: float
1.2_r; // call: operator "" _i("1.2") | kind: float
1.2_t; // call: operator<'1', '2'> "" _x() | kind: float
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-unsigned | |-unsigned
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-operator | | |-operator
| | |-"" | | |-""
| | |-_s | | |-_f
| | `-ParametersAndQualifiers | | `-ParametersAndQualifiers
| | |-( | | |-(
| | |-SimpleDeclaration | | |-SimpleDeclaration
| | | |-const | | | |-long
| | | |-char | | | `-double
| | | `-SimpleDeclarator
| | | `-*
| | |-,
| | |-SimpleDeclaration
| | | `-size_t
| | `-) | | `-)
| `-; | `-;
|-SimpleDeclaration |-SimpleDeclaration
| |-unsigned | |-unsigned
| |-SimpleDeclarator | |-SimpleDeclarator
| | |-operator | | |-operator
| | |-"" | | |-""
| | |-_r | | |-_r
Show All 28 Lines`-SimpleDeclaration
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-ExpressionStatement |-ExpressionStatement
| |-IntegerUserDefinedLiteralExpression
| | `-12_i
| `-;
|-ExpressionStatement
| |-FloatUserDefinedLiteralExpression | |-FloatUserDefinedLiteralExpression
| | `-1.2_f | | `-1.2_f
| `-; | `-;
|-ExpressionStatement |-ExpressionStatement
| |-CharUserDefinedLiteralExpression
| | `-'2'_c
| `-;
|-ExpressionStatement
| |-StringUserDefinedLiteralExpression
| | `-"12"_s
| `-;
|-ExpressionStatement
| |-IntegerUserDefinedLiteralExpression
| | `-12_r
| `-;
|-ExpressionStatement
| |-FloatUserDefinedLiteralExpression | |-FloatUserDefinedLiteralExpression
| | `-1.2_r | | `-1.2_r
| `-; | `-;
|-ExpressionStatement |-ExpressionStatement
| |-IntegerUserDefinedLiteralExpression
| | `-12_t
| `-;
|-ExpressionStatement
| |-FloatUserDefinedLiteralExpression | |-FloatUserDefinedLiteralExpression
| | `-1.2_t | | `-1.2_t
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, IntegerLiteralLongLong) { TEST_P(SyntaxTreeTest, IntegerLiteralLongLong) {
▲ Show 20 Lines • Show All 818 Lines • ▼ Show 20 Lines `-CompoundStatement
| | |-xor_eq | | |-xor_eq
| | `-IntegerLiteralExpression | | `-IntegerLiteralExpression
| | `-3 | | `-3
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, NestedBinaryOperator) { TEST_P(SyntaxTreeTest, NestedBinaryOperatorWithParenthesis) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

BinaryOperator_NestedWithParenthesis

gribozavr2: BinaryOperator_NestedWithParenthesis
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
void test(int a, int b) { void test() {
(1 + 2) * (4 / 2); (1 + 2) * (4 / 2);
a + b + 42;
a = b = 42;
a + b * 4 + 2;
a % 2 + b * 42;
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | `-a
| |-,
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | `-b
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-ExpressionStatement |-ExpressionStatement
| |-BinaryOperatorExpression | |-BinaryOperatorExpression
| | |-ParenExpression | | |-ParenExpression
| | | |-( | | | |-(
| | | |-BinaryOperatorExpression | | | |-BinaryOperatorExpression
Show All 9 Lines `-CompoundStatement
| | |-BinaryOperatorExpression | | |-BinaryOperatorExpression
| | | |-IntegerLiteralExpression | | | |-IntegerLiteralExpression
| | | | `-4 | | | | `-4
| | | |-/ | | | |-/
| | | `-IntegerLiteralExpression | | | `-IntegerLiteralExpression
| | | `-2 | | | `-2
| | `-) | | `-)
| `-; | `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, NestedBinaryOperatorWithAssociativity) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

BinaryOperator_Associativity

gribozavr2: BinaryOperator_Associativity
EXPECT_TRUE(treeDumpEqual(
R"cpp(
void test(int a, int b) {
a + b + 42;
a = b = 42;
}
)cpp",
R"txt(
*: TranslationUnit
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | `-a
| |-,
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | `-b
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement |-ExpressionStatement
| |-BinaryOperatorExpression | |-BinaryOperatorExpression
| | |-BinaryOperatorExpression | | |-BinaryOperatorExpression
| | | |-IdExpression | | | |-IdExpression
| | | | `-UnqualifiedId | | | | `-UnqualifiedId
| | | | `-a | | | | `-a
| | | |-+ | | | |-+
| | | `-IdExpression | | | `-IdExpression
Show All 12 Lines `-CompoundStatement
| | `-BinaryOperatorExpression | | `-BinaryOperatorExpression
| | |-IdExpression | | |-IdExpression
| | | `-UnqualifiedId | | | `-UnqualifiedId
| | | `-b | | | `-b
| | |-= | | |-=
| | `-IntegerLiteralExpression | | `-IntegerLiteralExpression
| | `-42 | | `-42
| `-; | `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, NestedBinaryOperatorWithPrecedence) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

BinaryOperator_Precedence

gribozavr2: BinaryOperator_Precedence
EXPECT_TRUE(treeDumpEqual(
R"cpp(
void test() {
1 + 2 * 3 + 4;
1 % 2 + 3 * 4;
}
)cpp",
R"txt(
*: TranslationUnit
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement |-ExpressionStatement
| |-BinaryOperatorExpression | |-BinaryOperatorExpression
| | |-BinaryOperatorExpression | | |-BinaryOperatorExpression
| | | |-IdExpression | | | |-IntegerLiteralExpression
| | | | `-UnqualifiedId | | | | `-1
| | | | `-a
| | | |-+ | | | |-+
| | | `-BinaryOperatorExpression | | | `-BinaryOperatorExpression
| | | |-IdExpression | | | |-IntegerLiteralExpression
| | | | `-UnqualifiedId | | | | `-2
| | | | `-b
| | | |-* | | | |-*
| | | `-IntegerLiteralExpression | | | `-IntegerLiteralExpression
| | | `-4 | | | `-3
| | |-+ | | |-+
| | `-IntegerLiteralExpression | | `-IntegerLiteralExpression
| | `-2 | | `-4
| `-; | `-;
|-ExpressionStatement |-ExpressionStatement
| |-BinaryOperatorExpression | |-BinaryOperatorExpression
| | |-BinaryOperatorExpression | | |-BinaryOperatorExpression
| | | |-IdExpression | | | |-IntegerLiteralExpression
| | | | `-UnqualifiedId | | | | `-1
| | | | `-a
| | | |-% | | | |-%
| | | `-IntegerLiteralExpression | | | `-IntegerLiteralExpression
| | | `-2 | | | `-2
| | |-+ | | |-+
| | `-BinaryOperatorExpression | | `-BinaryOperatorExpression
| | |-IdExpression | | |-IntegerLiteralExpression
| | | `-UnqualifiedId | | | `-3
| | | `-b
| | |-* | | |-*
| | `-IntegerLiteralExpression | | `-IntegerLiteralExpression
| | `-42 | | `-4
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, UserDefinedBinaryOperator) { TEST_P(SyntaxTreeTest, UserDefinedAssignmentOperator) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

UserDefinedOperator => OverloadedOperator?

"user-defined" seems to suggest that the operator was previously not a thing in C++.

gribozavr2: UserDefinedOperator => OverloadedOperator? "user-defined" seems to suggest that the operator…
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

Actually it is a very good point! Thanks!

eduucaldas: Actually it is a very good point! Thanks!
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
struct X { struct X {
X& operator=(const X&); X& operator=(const X&);
friend X operator+(X, const X&);
friend bool operator<(const X&, const X&);
friend X operator<<(X&, const X&);
X operator,(X&);
X operator->*(int);
// TODO: Unbox operators in syntax tree.
// Represent operators by `+` instead of `IdExpression-UnqualifiedId-+`
}; };
void test(X x, X y, X* xp, int X::* pmi) { void test(X x, X y) {
x = y; x = y;
x + y;
x < y;
x << y;
x, y;
xp->*pmi;
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-struct | |-struct
| |-X | |-X
| |-{ | |-{
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-X | | |-X
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-& | | | |-&
| | | |-operator | | | |-operator
| | | |-= | | | |-=
| | | `-ParametersAndQualifiers | | | `-ParametersAndQualifiers
| | | |-( | | | |-(
| | | |-SimpleDeclaration | | | |-SimpleDeclaration
| | | | |-const | | | | |-const
| | | | |-X | | | | |-X
| | | | `-SimpleDeclarator | | | | `-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, UserDefinedPlusOperator) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
friend X operator+(X, const X&);
};
void test(X x, X y) {
x + y;
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-UnknownDeclaration | |-UnknownDeclaration
| | `-SimpleDeclaration | | `-SimpleDeclaration
| | |-friend | | |-friend
| | |-X | | |-X
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-operator | | | |-operator
| | | |-+ | | | |-+
| | | `-ParametersAndQualifiers | | | `-ParametersAndQualifiers
| | | |-( | | | |-(
| | | |-SimpleDeclaration | | | |-SimpleDeclaration
| | | | `-X | | | | `-X
| | | |-, | | | |-,
| | | |-SimpleDeclaration | | | |-SimpleDeclaration
| | | | |-const | | | | |-const
| | | | |-X | | | | |-X
| | | | `-SimpleDeclarator | | | | `-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, UserDefinedLessOperator) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
friend bool operator<(const X&, const X&);
};
void test(X x, X y) {
x < y;
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-UnknownDeclaration | |-UnknownDeclaration
| | `-SimpleDeclaration | | `-SimpleDeclaration
| | |-friend | | |-friend
| | |-bool | | |-bool
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-operator | | | |-operator
| | | |-< | | | |-<
| | | `-ParametersAndQualifiers | | | `-ParametersAndQualifiers
| | | |-( | | | |-(
| | | |-SimpleDeclaration | | | |-SimpleDeclaration
| | | | |-const | | | | |-const
| | | | |-X | | | | |-X
| | | | `-SimpleDeclarator | | | | `-SimpleDeclarator
| | | | `-& | | | | `-&
| | | |-, | | | |-,
| | | |-SimpleDeclaration | | | |-SimpleDeclaration
| | | | |-const | | | | |-const
| | | | |-X | | | | |-X
| | | | `-SimpleDeclarator | | | | `-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, UserDefinedShiftOperator) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

UserDefinedOperator_LeftShift

gribozavr2: UserDefinedOperator_LeftShift
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
friend X operator<<(X&, const X&);
};
void test(X x, X y) {
x << y;
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-UnknownDeclaration | |-UnknownDeclaration
| | `-SimpleDeclaration | | `-SimpleDeclaration
| | |-friend | | |-friend
| | |-X | | |-X
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-operator | | | |-operator
| | | |-<< | | | |-<<
| | | `-ParametersAndQualifiers | | | `-ParametersAndQualifiers
| | | |-( | | | |-(
| | | |-SimpleDeclaration | | | |-SimpleDeclaration
| | | | |-X | | | | |-X
| | | | `-SimpleDeclarator | | | | `-SimpleDeclarator
| | | | `-& | | | | `-&
| | | |-, | | | |-,
| | | |-SimpleDeclaration | | | |-SimpleDeclaration
| | | | |-const | | | | |-const
| | | | |-X | | | | |-X
| | | | `-SimpleDeclarator | | | | `-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, UserDefinedCommaOperator) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
X operator,(X&);
};
void test(X x, X y) {
x, y;
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-X | | |-X
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-operator | | | |-operator
| | | |-, | | | |-,
| | | `-ParametersAndQualifiers | | | `-ParametersAndQualifiers
| | | |-( | | | |-(
| | | |-SimpleDeclaration | | | |-SimpleDeclaration
| | | | |-X | | | | |-X
| | | | `-SimpleDeclarator | | | | `-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, UserDefinedArrowPointerOperator) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

UserDefinedOperator_PointerToMember

gribozavr2: UserDefinedOperator_PointerToMember
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
X operator->*(int);
};
void test(X* xp, int X::* pmi) {
xp->*pmi;
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-X | | |-X
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-operator | | | |-operator
| | | |-->* | | | |-->*
| | | `-ParametersAndQualifiers | | | `-ParametersAndQualifiers
| | | |-( | | | |-(
| | | |-SimpleDeclaration | | | |-SimpleDeclaration
| | | | `-int | | | | `-int
| | | `-) | | | `-)
| | `-; | | `-;
| |-} | |-}
| `-; | `-;
`-SimpleDeclaration `-SimpleDeclaration
|-void |-void
|-SimpleDeclarator |-SimpleDeclarator
| |-test | |-test
| `-ParametersAndQualifiers | `-ParametersAndQualifiers
| |-( | |-(
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-X | | |-X
| | `-SimpleDeclarator | | `-SimpleDeclarator
| | `-x
| |-,
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-y
| |-,
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | |-* | | |-*
| | `-xp | | `-xp
| |-, | |-,
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-int | | |-int
| | `-SimpleDeclarator | | `-SimpleDeclarator
| | |-MemberPointer | | |-MemberPointer
| | | |-X | | | |-X
| | | |-:: | | | |-::
| | | `-* | | | `-*
| | `-pmi | | `-pmi
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-ExpressionStatement |-ExpressionStatement
| |-BinaryOperatorExpression | |-BinaryOperatorExpression
| | |-IdExpression | | |-IdExpression
| | | `-UnqualifiedId | | | `-UnqualifiedId
| | | `-x
| | |-=
| | `-IdExpression
| | `-UnqualifiedId
| | `-y
| `-;
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-UnknownExpression
| | | `-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | |-+
| | `-IdExpression
| | `-UnqualifiedId
| | `-y
| `-;
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | |-<
| | `-IdExpression
| | `-UnqualifiedId
| | `-y
| `-;
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | |-<<
| | `-IdExpression
| | `-UnqualifiedId
| | `-y
| `-;
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-x
| | |-,
| | `-IdExpression
| | `-UnqualifiedId
| | `-y
| `-;
|-ExpressionStatement
| |-BinaryOperatorExpression
| | |-IdExpression
| | | `-UnqualifiedId
| | | `-xp | | | `-xp
| | |-->* | | |-->*
| | `-IdExpression | | `-IdExpression
| | `-UnqualifiedId | | `-UnqualifiedId
| | `-pmi | | `-pmi
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, UserDefinedUnaryPrefixOperator) { TEST_P(SyntaxTreeTest, UserDefinedPrefixIncrOperator) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

PrefixIncrement

gribozavr2: PrefixIncrement
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
struct X { struct X {
X operator++(); X operator++();
bool operator!();
X* operator&();
}; };
void test(X x) { void test(X x) {
++x; ++x;
!x;
&x;
} }
)cpp", )cpp",
R"txt( R"txt(
*: TranslationUnit *: TranslationUnit
|-SimpleDeclaration |-SimpleDeclaration
| |-struct | |-struct
| |-X | |-X
| |-{ | |-{
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-X | | |-X
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-operator | | | |-operator
| | | |-++ | | | |-++
| | | `-ParametersAndQualifiers | | | `-ParametersAndQualifiers
| | | |-( | | | |-(
| | | `-) | | | `-)
| | `-; | | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-++
| | `-IdExpression
| | `-UnqualifiedId
| | `-x
| `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, UserDefinedExclamOperator) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

UserDefinedOperator_Negation

gribozavr2: UserDefinedOperator_Negation
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
bool operator!();
};
void test(X x) {
!x;
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-bool | | |-bool
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-operator | | | |-operator
| | | |-! | | | |-!
| | | `-ParametersAndQualifiers | | | `-ParametersAndQualifiers
| | | |-( | | | |-(
| | | `-) | | | `-)
| | `-; | | `-;
| |-}
| `-;
`-SimpleDeclaration
|-void
|-SimpleDeclarator
| |-test
| `-ParametersAndQualifiers
| |-(
| |-SimpleDeclaration
| | |-X
| | `-SimpleDeclarator
| | `-x
| `-)
`-CompoundStatement
|-{
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-!
| | `-IdExpression
| | `-UnqualifiedId
| | `-x
| `-;
`-}
)txt"));
}
TEST_P(SyntaxTreeTest, UserDefinedReferenceOperator) {
if (!GetParam().isCXX()) {
return;
}
EXPECT_TRUE(treeDumpEqual(
R"cpp(
struct X {
X* operator&();
};
void test(X x) {
&x;
}
)cpp",
R"txt(
*: TranslationUnit
|-SimpleDeclaration
| |-struct
| |-X
| |-{
| |-SimpleDeclaration | |-SimpleDeclaration
| | |-X | | |-X
| | |-SimpleDeclarator | | |-SimpleDeclarator
| | | |-* | | | |-*
| | | |-operator | | | |-operator
| | | |-& | | | |-&
| | | `-ParametersAndQualifiers | | | `-ParametersAndQualifiers
| | | |-( | | | |-(
Show All 11 Lines`-SimpleDeclaration
| | |-X | | |-X
| | `-SimpleDeclarator | | `-SimpleDeclarator
| | `-x | | `-x
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-ExpressionStatement |-ExpressionStatement
| |-PrefixUnaryOperatorExpression | |-PrefixUnaryOperatorExpression
| | |-++
| | `-IdExpression
| | `-UnqualifiedId
| | `-x
| `-;
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-!
| | `-IdExpression
| | `-UnqualifiedId
| | `-x
| `-;
|-ExpressionStatement
| |-PrefixUnaryOperatorExpression
| | |-& | | |-&
| | `-IdExpression | | `-IdExpression
| | `-UnqualifiedId | | `-UnqualifiedId
| | `-x | | `-x
| `-; | `-;
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, UserDefinedUnaryPostfixOperator) { TEST_P(SyntaxTreeTest, UserDefinedUnaryPostfixOperator) {
gribozavr2Unsubmitted
Done
ReplyInline Actions

PostfixIncrement

Also, group it right after prefix increment?

gribozavr2: PostfixIncrement Also, group it right after prefix increment?
eduucaldasAuthorUnsubmitted
Done
ReplyInline Actions

I'm grouping together Prefix operators. But you're right it makes sense to put them close to each other. I've put PrefixIncrement as the last Prefix operator to achieve that

eduucaldas: I'm grouping together Prefix operators. But you're right it makes sense to put them close to…
if (!GetParam().isCXX()) { if (!GetParam().isCXX()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
struct X { struct X {
X operator++(int); X operator++(int);
}; };
▲ Show 20 Lines • Show All 1,719 Lines • Show Last 20 Lines