This is an archive of the discontinued LLVM Phabricator instance.

Differential D86345

[SyntaxTree] Use annotations in Statement tests
ClosedPublic

Authored by eduucaldas on Aug 21 2020, 5:20 AM.

Details

Reviewers
gribozavr2
Commits
rG1beb11c61ae4: [SyntaxTree] Use annotations in Statement tests

Diff Detail

Event Timeline

eduucaldas created this revision.Aug 21 2020, 5:20 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 21 2020, 5:20 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
eduucaldas requested review of this revision.Aug 21 2020, 5:20 AM
eduucaldas added a reviewer: gribozavr2.Aug 21 2020, 5:26 AM

Sorry for doing this after asking for review.

I think it might be interesting landing this patch before : https://reviews.llvm.org/D85330

Harbormaster completed remote builds in B69129: Diff 287014.Aug 21 2020, 5:55 AM
gribozavr2 accepted this revision.Aug 21 2020, 6:32 AM
This revision is now accepted and ready to land.Aug 21 2020, 6:32 AM
Closed by commit rG1beb11c61ae4: [SyntaxTree] Use annotations in Statement tests (authored by eduucaldas). · Explain WhyAug 21 2020, 7:51 AM
This revision was automatically updated to reflect the committed changes.
eduucaldas added a commit: rG1beb11c61ae4: [SyntaxTree] Use annotations in Statement tests.

Revision Contents

PathSize
clang/
unittests/
Tooling/
Syntax/
354 lines

Diff 287014

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines`-SimpleDeclaration
| `-) | `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
`-} `-}
)txt")); )txt"));
} }
TEST_P(SyntaxTreeTest, If) { TEST_P(SyntaxTreeTest, If) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
int main() { void test() {
if (1) {} [[if (1) {}]]
if (1) {} else if (0) {} [[if (1) {} else if (0) {}]]
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit IfStatement
`-SimpleDeclaration |-if
|-int |-(
|-SimpleDeclarator |-IntegerLiteralExpression
| |-main | `-1
| `-ParametersAndQualifiers |-)
| |-(
| `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-IfStatement `-}
| |-if )txt",
| |-( R"txt(
| |-IntegerLiteralExpression IfStatement
| | `-1 |-if
| |-) |-(
| `-CompoundStatement |-IntegerLiteralExpression
| |-{ | `-1
| `-} |-)
|-IfStatement |-CompoundStatement
| |-if
| |-(
| |-IntegerLiteralExpression
| | `-1
| |-)
| |-CompoundStatement
| | |-{
| | `-}
| |-else
| `-IfStatement
| |-if
| |-(
| |-IntegerLiteralExpression
| | `-0
| |-)
| `-CompoundStatement
| |-{ | |-{
| `-} | `-}
|-else
`-IfStatement
|-if
|-(
|-IntegerLiteralExpression
| `-0
|-)
`-CompoundStatement
|-{
`-} `-}
)txt")); )txt"}));
} }
TEST_P(SyntaxTreeTest, For) { TEST_P(SyntaxTreeTest, For) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
for (;;) {} [[for (;;) {}]]
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit ForStatement
`-SimpleDeclaration |-for
|-void |-(
|-SimpleDeclarator |-;
| |-test |-;
| `-ParametersAndQualifiers |-)
| |-(
| `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-ForStatement
| |-for
| |-(
| |-;
| |-;
| |-)
| `-CompoundStatement
| |-{
| `-}
`-} `-}
)txt")); )txt"}));
} }
TEST_P(SyntaxTreeTest, RangeBasedFor) { TEST_P(SyntaxTreeTest, RangeBasedFor) {
if (!GetParam().isCXX11OrLater()) { if (!GetParam().isCXX11OrLater()) {
return; return;
} }
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
int a[3]; int a[3];
for (int x : a) [[for (int x : a)
; ;]]
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit RangeBasedForStatement
`-SimpleDeclaration |-for
|-void |-(
|-SimpleDeclarator |-SimpleDeclaration
| |-test | |-int
| `-ParametersAndQualifiers | |-SimpleDeclarator
| |-( | | `-x
| `-) | `-:
`-CompoundStatement |-IdExpression
|-{ | `-UnqualifiedId
|-DeclarationStatement | `-a
| |-SimpleDeclaration |-)
| | |-int `-EmptyStatement
| | `-SimpleDeclarator `-;
| | |-a )txt"}));
| | `-ArraySubscript
| | |-[
| | |-IntegerLiteralExpression
| | | `-3
| | `-]
| `-;
|-RangeBasedForStatement
| |-for
| |-(
| |-SimpleDeclaration
| | |-int
| | |-SimpleDeclarator
| | | `-x
| | `-:
| |-IdExpression
| | `-UnqualifiedId
| | `-a
| |-)
| `-EmptyStatement
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, DeclarationStatement) { TEST_P(SyntaxTreeTest, DeclarationStatement) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
int a = 10; [[int a = 10;]]
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit DeclarationStatement
`-SimpleDeclaration |-SimpleDeclaration
|-void | |-int
|-SimpleDeclarator | `-SimpleDeclarator
| |-test | |-a
| `-ParametersAndQualifiers | |-=
| |-( | `-IntegerLiteralExpression
| `-) | `-10
`-CompoundStatement `-;
|-{ )txt"}));
|-DeclarationStatement
| |-SimpleDeclaration
| | |-int
| | `-SimpleDeclarator
| | |-a
| | |-=
| | `-IntegerLiteralExpression
| | `-10
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, Switch) { TEST_P(SyntaxTreeTest, Switch) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
switch (1) { [[switch (1) {
case 0: case 0:
default:; default:;
} }]]
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit SwitchStatement
`-SimpleDeclaration |-switch
|-void |-(
|-SimpleDeclarator |-IntegerLiteralExpression
| |-test | `-1
| `-ParametersAndQualifiers |-)
| |-(
| `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-SwitchStatement |-CaseStatement
| |-switch | |-case
| |-(
| |-IntegerLiteralExpression | |-IntegerLiteralExpression
| | `-1 | | `-0
| |-) | |-:
| `-CompoundStatement | `-DefaultStatement
| |-{ | |-default
| |-CaseStatement | |-:
| | |-case | `-EmptyStatement
| | |-IntegerLiteralExpression | `-;
| | | `-0
| | |-:
| | `-DefaultStatement
| | |-default
| | |-:
| | `-EmptyStatement
| | `-;
| `-}
`-} `-}
)txt")); )txt"}));
} }
TEST_P(SyntaxTreeTest, While) { TEST_P(SyntaxTreeTest, While) {
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
void test() { void test() {
while (1) { continue; break; } [[while (1) { continue; break; }]]
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit WhileStatement
`-SimpleDeclaration |-while
|-void |-(
|-SimpleDeclarator |-IntegerLiteralExpression
| |-test | `-1
| `-ParametersAndQualifiers |-)
| |-(
| `-)
`-CompoundStatement `-CompoundStatement
|-{ |-{
|-WhileStatement |-ContinueStatement
| |-while | |-continue
| |-( | `-;
| |-IntegerLiteralExpression |-BreakStatement
| | `-1 | |-break
| |-) | `-;
| `-CompoundStatement
| |-{
| |-ContinueStatement
| | |-continue
| | `-;
| |-BreakStatement
| | |-break
| | `-;
| `-}
`-} `-}
)txt")); )txt"}));
} }
TEST_P(SyntaxTreeTest, UnhandledStatement) { TEST_P(SyntaxTreeTest, UnhandledStatement) {
// Unhandled statements should end up as 'unknown statement'. // Unhandled statements should end up as 'unknown statement'.
// This example uses a 'label statement', which does not yet have a syntax // This example uses a 'label statement', which does not yet have a syntax
// counterpart. // counterpart.
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqualOnAnnotations(
R"cpp( R"cpp(
int main() { int test() {
foo: return 100; [[foo: return 100;]]
} }
)cpp", )cpp",
R"txt( {R"txt(
*: TranslationUnit UnknownStatement
`-SimpleDeclaration |-foo
|-int |-:
|-SimpleDeclarator `-ReturnStatement
| |-main |-return
| `-ParametersAndQualifiers |-IntegerLiteralExpression
| |-( | `-100
| `-) `-;
`-CompoundStatement )txt"}));
|-{
|-UnknownStatement
| |-foo
| |-:
| `-ReturnStatement
| |-return
| |-IntegerLiteralExpression
| | `-100
| `-;
`-}
)txt"));
} }
TEST_P(SyntaxTreeTest, Expressions) { TEST_P(SyntaxTreeTest, Expressions) {
// expressions should be wrapped in 'ExpressionStatement' when they appear // expressions should be wrapped in 'ExpressionStatement' when they appear
// in a statement position. // in a statement position.
EXPECT_TRUE(treeDumpEqual( EXPECT_TRUE(treeDumpEqual(
R"cpp( R"cpp(
void test() { void test() {
▲ Show 20 Lines • Show All 3,911 Lines • Show Last 20 Lines