From c8c92b54d74c1b9256f9aed6ba89d66fbd1d01ae Mon Sep 17 00:00:00 2001 From: Eduardo Caldas Date: Fri, 14 Aug 2020 09:53:45 +0000 Subject: [PATCH] [SyntaxTree] Use Annotations based tests for expressions In this process we also create some other tests, in order to not lose coverage when focusing on the annotated code Differential Revision: https://reviews.llvm.org/D85962 --- clang/unittests/Tooling/Syntax/BuildTreeTest.cpp | 3693 ++++++++-------------- clang/unittests/Tooling/Syntax/TreeTestBase.cpp | 24 +- 2 files changed, 1383 insertions(+), 2334 deletions(-) diff --git a/clang/unittests/Tooling/Syntax/BuildTreeTest.cpp b/clang/unittests/Tooling/Syntax/BuildTreeTest.cpp index 211e8b1..fd858df 100644 --- a/clang/unittests/Tooling/Syntax/BuildTreeTest.cpp +++ b/clang/unittests/Tooling/Syntax/BuildTreeTest.cpp @@ -437,672 +437,355 @@ void test() { } TEST_P(SyntaxTreeTest, UnqualifiedId_Identifier) { - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test(int a) { - a; + [[a]]; } )cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-int - | | `-SimpleDeclarator - | | `-a - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - `-} -)txt")); + {R"txt( +IdExpression +`-UnqualifiedId + `-a +)txt"})); } TEST_P(SyntaxTreeTest, UnqualifiedId_OperatorFunctionId) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { friend X operator+(const X&, const X&); }; void test(X x) { - operator+(x, x); -} -)cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-UnknownDeclaration -| | `-SimpleDeclaration -| | |-friend -| | |-X -| | |-SimpleDeclarator -| | | |-operator -| | | |-+ -| | | `-ParametersAndQualifiers -| | | |-( -| | | |-SimpleDeclaration -| | | | |-const -| | | | |-X -| | | | `-SimpleDeclarator -| | | | `-& -| | | |-, -| | | |-SimpleDeclaration -| | | | |-const -| | | | |-X -| | | | `-SimpleDeclarator -| | | | `-& -| | | `-) -| | `-; -| |-} -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-X - | | `-SimpleDeclarator - | | `-x - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-UnknownExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | |-operator - | | | `-+ - | | |-( - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-x - | | |-, - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-x - | | `-) - | `-; - `-} -)txt")); + [[operator+(x, x)]]; +} +)cpp", + {R"txt( +UnknownExpression +|-IdExpression +| `-UnqualifiedId +| |-operator +| `-+ +|-( +|-IdExpression +| `-UnqualifiedId +| `-x +|-, +|-IdExpression +| `-UnqualifiedId +| `-x +`-) +)txt"})); } TEST_P(SyntaxTreeTest, UnqualifiedId_ConversionFunctionId) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { operator int(); }; void test(X x) { // TODO: Expose `id-expression` from `MemberExpr` - x.operator int(); + [[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 - | |-UnknownExpression - | | |-UnknownExpression - | | | |-IdExpression - | | | | `-UnqualifiedId - | | | | `-x - | | | |-. - | | | |-operator - | | | `-int - | | |-( - | | `-) - | `-; - `-} -)txt")); + {R"txt( +UnknownExpression +|-UnknownExpression +| |-IdExpression +| | `-UnqualifiedId +| | `-x +| |-. +| |-operator +| `-int +|-( +`-) +)txt"})); } TEST_P(SyntaxTreeTest, UnqualifiedId_LiteralOperatorId) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( unsigned operator "" _w(char); void test() { - operator "" _w('1'); + [[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")); + {R"txt( +UnknownExpression +|-IdExpression +| `-UnqualifiedId +| |-operator +| |-"" +| `-_w +|-( +|-CharacterLiteralExpression +| `-'1' +`-) +)txt"})); } TEST_P(SyntaxTreeTest, UnqualifiedId_Destructor) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { }; void test(X x) { // TODO: Expose `id-expression` from `MemberExpr` - x.~X(); + [[x.~X()]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-} -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-X - | | `-SimpleDeclarator - | | `-x - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-UnknownExpression - | | |-UnknownExpression - | | | |-IdExpression - | | | | `-UnqualifiedId - | | | | `-x - | | | |-. - | | | |-~ - | | | `-X - | | |-( - | | `-) - | `-; - `-} -)txt")); + {R"txt( +UnknownExpression +|-UnknownExpression +| |-IdExpression +| | `-UnqualifiedId +| | `-x +| |-. +| |-~ +| `-X +|-( +`-) +)txt"})); } TEST_P(SyntaxTreeTest, UnqualifiedId_DecltypeDestructor) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { }; void test(X x) { // TODO: Expose `id-expression` from `MemberExpr` - x.~decltype(x)(); -} -)cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-} -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-X - | | `-SimpleDeclarator - | | `-x - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-UnknownExpression - | | |-UnknownExpression - | | | |-IdExpression - | | | | `-UnqualifiedId - | | | | `-x - | | | |-. - | | | `-~ - | | |-decltype - | | |-( - | | |-x - | | |-) - | | |-( - | | `-) - | `-; - `-} -)txt")); + [[x.~decltype(x)()]]; +} +)cpp", + {R"txt( +UnknownExpression +|-UnknownExpression +| |-IdExpression +| | `-UnqualifiedId +| | `-x +| |-. +| `-~ +|-decltype +|-( +|-x +|-) +|-( +`-) +)txt"})); } TEST_P(SyntaxTreeTest, UnqualifiedId_TemplateId) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( template T f(); void test() { - f(); + [[f()]]; } )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")); + {R"txt( +UnknownExpression +|-IdExpression +| `-UnqualifiedId +| |-f +| |-< +| |-int +| `-> +|-( +`-) +)txt"})); } TEST_P(SyntaxTreeTest, QualifiedId_NamespaceSpecifier) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( namespace n { struct S { }; } void test() { - ::n::S s1; - n::S s2; + [[::n::S s1]]; + [[n::S s2]]; } )cpp", - R"txt( -*: TranslationUnit -|-NamespaceDefinition -| |-namespace -| |-n -| |-{ -| |-SimpleDeclaration -| | |-struct -| | |-S -| | |-{ -| | |-} -| | `-; -| `-} -`-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")); + {R"txt( +SimpleDeclaration +|-NestedNameSpecifier +| |-:: +| |-IdentifierNameSpecifier +| | `-n +| `-:: +|-S +`-SimpleDeclarator + `-UnknownExpression + `-s1 +)txt", + R"txt( +SimpleDeclaration +|-NestedNameSpecifier +| |-IdentifierNameSpecifier +| | `-n +| `-:: +|-S +`-SimpleDeclarator + `-UnknownExpression + `-s2 +)txt"})); } TEST_P(SyntaxTreeTest, QualifiedId_TemplateSpecifier) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( template struct ST { struct S { }; }; void test() { - ::template ST::S s1; - ::ST::S s2; + [[::template ST::S s1]]; + [[::ST::S s2]]; } )cpp", - R"txt( -*: TranslationUnit -|-TemplateDeclaration -| |-template -| |-< -| |-UnknownDeclaration -| | |-typename -| | `-T -| |-> -| `-SimpleDeclaration -| |-struct -| |-ST -| |-{ -| |-SimpleDeclaration -| | |-struct -| | |-S -| | |-{ -| | |-} -| | `-; -| |-} -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-DeclarationStatement - | |-SimpleDeclaration - | | |-NestedNameSpecifier - | | | |-:: - | | | |-SimpleTemplateNameSpecifier - | | | | |-template - | | | | |-ST - | | | | |-< - | | | | |-int - | | | | `-> - | | | `-:: - | | |-S - | | `-SimpleDeclarator - | | `-UnknownExpression - | | `-s1 - | `-; - |-DeclarationStatement - | |-SimpleDeclaration - | | |-NestedNameSpecifier - | | | |-:: - | | | |-SimpleTemplateNameSpecifier - | | | | |-ST - | | | | |-< - | | | | |-int - | | | | `-> - | | | `-:: - | | |-S - | | `-SimpleDeclarator - | | `-UnknownExpression - | | `-s2 - | `-; - `-} -)txt")); + {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, QualifiedId_DecltypeSpecifier) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct S { static void f(){} }; void test(S s) { - decltype(s)::f(); + [[decltype(s)::f()]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-S -| |-{ -| |-SimpleDeclaration -| | |-static -| | |-void -| | |-SimpleDeclarator -| | | |-f -| | | `-ParametersAndQualifiers -| | | |-( -| | | `-) -| | `-CompoundStatement -| | |-{ -| | `-} -| |-} -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-S - | | `-SimpleDeclarator - | | `-s - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-UnknownExpression - | | |-IdExpression - | | | |-NestedNameSpecifier - | | | | |-DecltypeNameSpecifier - | | | | | |-decltype - | | | | | |-( - | | | | | |-IdExpression - | | | | | | `-UnqualifiedId - | | | | | | `-s - | | | | | `-) - | | | | `-:: - | | | `-UnqualifiedId - | | | `-f - | | |-( - | | `-) - | `-; - `-} -)txt")); + {R"txt( +UnknownExpression +|-IdExpression +| |-NestedNameSpecifier +| | |-DecltypeNameSpecifier +| | | |-decltype +| | | |-( +| | | |-IdExpression +| | | | `-UnqualifiedId +| | | | `-s +| | | `-) +| | `-:: +| `-UnqualifiedId +| `-f +|-( +`-) +)txt"})); } TEST_P(SyntaxTreeTest, QualifiedId_OptionalTemplateKw) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct S { template static U f(); }; void test() { - S::f(); - S::template f(); -} -)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 - | |-UnknownExpression - | | |-IdExpression - | | | |-NestedNameSpecifier - | | | | |-IdentifierNameSpecifier - | | | | | `-S - | | | | `-:: - | | | `-UnqualifiedId - | | | |-f - | | | |-< - | | | |-int - | | | `-> - | | |-( - | | `-) - | `-; - |-ExpressionStatement - | |-UnknownExpression - | | |-IdExpression - | | | |-NestedNameSpecifier - | | | | |-IdentifierNameSpecifier - | | | | | `-S - | | | | `-:: - | | | |-template - | | | `-UnqualifiedId - | | | |-f - | | | |-< - | | | |-int - | | | `-> - | | |-( - | | `-) - | `-; - `-} -)txt")); + [[S::f()]]; + [[S::template f()]]; +} +)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) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( namespace n { template @@ -1112,80 +795,33 @@ namespace n { }; } void test() { - ::n::template ST::template f(); -} -)cpp", - R"txt( -*: TranslationUnit -|-NamespaceDefinition -| |-namespace -| |-n -| |-{ -| |-TemplateDeclaration -| | |-template -| | |-< -| | |-UnknownDeclaration -| | | |-typename -| | | `-T -| | |-> -| | `-SimpleDeclaration -| | |-struct -| | |-ST -| | |-{ -| | |-TemplateDeclaration -| | | |-template -| | | |-< -| | | |-UnknownDeclaration -| | | | |-typename -| | | | `-U -| | | |-> -| | | `-SimpleDeclaration -| | | |-static -| | | |-U -| | | |-SimpleDeclarator -| | | | |-f -| | | | `-ParametersAndQualifiers -| | | | |-( -| | | | `-) -| | | `-; -| | |-} -| | `-; -| `-} -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-UnknownExpression - | | |-IdExpression - | | | |-NestedNameSpecifier - | | | | |-:: - | | | | |-IdentifierNameSpecifier - | | | | | `-n - | | | | |-:: - | | | | |-SimpleTemplateNameSpecifier - | | | | | |-template - | | | | | |-ST - | | | | | |-< - | | | | | |-int - | | | | | `-> - | | | | `-:: - | | | |-template - | | | `-UnqualifiedId - | | | |-f - | | | |-< - | | | |-int - | | | `-> - | | |-( - | | `-) - | `-; - `-} -)txt")); + [[::n::template ST::template f()]]; +} +)cpp", + {R"txt( +UnknownExpression +|-IdExpression +| |-NestedNameSpecifier +| | |-:: +| | |-IdentifierNameSpecifier +| | | `-n +| | |-:: +| | |-SimpleTemplateNameSpecifier +| | | |-template +| | | |-ST +| | | |-< +| | | |-int +| | | `-> +| | `-:: +| |-template +| `-UnqualifiedId +| |-f +| |-< +| |-int +| `-> +|-( +`-) +)txt"})); } TEST_P(SyntaxTreeTest, QualifiedId_DependentType) { @@ -1197,255 +833,152 @@ TEST_P(SyntaxTreeTest, QualifiedId_DependentType) { // tree when `-fdelayed-template-parsing` is active. return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( template void test() { - T::template U::f(); - T::U::f(); - T::template f<0>(); + [[T::template U::f()]]; + [[T::U::f()]]; + [[T::template f<0>()]]; } )cpp", - R"txt( -*: TranslationUnit -`-TemplateDeclaration - |-template - |-< - |-UnknownDeclaration - | |-typename - | `-T - |-> - `-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 - | | | `-UnqualifiedId - | | | |-f - | | | |-< - | | | |-IntegerLiteralExpression - | | | | `-0 - | | | `-> - | | |-( - | | `-) - | `-; - `-} -)txt")); + {R"txt( +UnknownExpression +|-IdExpression +| |-NestedNameSpecifier +| | |-IdentifierNameSpecifier +| | | `-T +| | |-:: +| | |-SimpleTemplateNameSpecifier +| | | |-template +| | | |-U +| | | |-< +| | | |-int +| | | `-> +| | `-:: +| `-UnqualifiedId +| `-f +|-( +`-) +)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) { - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - (1); - ((1)); - (1 + (2)); -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-ParenExpression - | | |-( - | | |-IntegerLiteralExpression - | | | `-1 - | | `-) - | `-; - |-ExpressionStatement - | |-ParenExpression - | | |-( - | | |-ParenExpression - | | | |-( - | | | |-IntegerLiteralExpression - | | | | `-1 - | | | `-) - | | `-) - | `-; - |-ExpressionStatement - | |-ParenExpression - | | |-( - | | |-BinaryOperatorExpression - | | | |-IntegerLiteralExpression - | | | | `-1 - | | | |-+ - | | | `-ParenExpression - | | | |-( - | | | |-IntegerLiteralExpression - | | | | `-2 - | | | `-) - | | `-) - | `-; - `-} -)txt")); + [[(1)]]; + [[((1))]]; + [[(1 + (2))]]; +} +)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_Char) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( unsigned operator "" _c(char); void test() { - '2'_c; + [['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")); + {R"txt( +CharUserDefinedLiteralExpression +`-'2'_c +)txt"})); } TEST_P(SyntaxTreeTest, UserDefinedLiteral_String) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( typedef decltype(sizeof(void *)) size_t; unsigned operator "" _s(const char*, size_t); void test() { - "12"_s; + [["12"_s]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-typedef -| |-decltype -| |-( -| |-UnknownExpression -| | |-sizeof -| | |-( -| | |-void -| | |-* -| | `-) -| |-) -| |-SimpleDeclarator -| | `-size_t -| `-; -|-SimpleDeclaration -| |-unsigned -| |-SimpleDeclarator -| | |-operator -| | |-"" -| | |-_s -| | `-ParametersAndQualifiers -| | |-( -| | |-SimpleDeclaration -| | | |-const -| | | |-char -| | | `-SimpleDeclarator -| | | `-* -| | |-, -| | |-SimpleDeclaration -| | | `-size_t -| | `-) -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-StringUserDefinedLiteralExpression - | | `-"12"_s - | `-; - `-} -)txt")); + {R"txt( +StringUserDefinedLiteralExpression +`-"12"_s +)txt"})); } TEST_P(SyntaxTreeTest, UserDefinedLiteral_Integer) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( unsigned operator "" _i(unsigned long long); unsigned operator "" _r(const char*); @@ -1453,89 +986,30 @@ template unsigned operator "" _t(); void test() { - 12_i; - 12_r; - 12_t; + [[12_i]]; + [[12_r]]; + [[12_t]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-unsigned -| |-SimpleDeclarator -| | |-operator -| | |-"" -| | |-_i -| | `-ParametersAndQualifiers -| | |-( -| | |-SimpleDeclaration -| | | |-unsigned -| | | |-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")); + {R"txt( +IntegerUserDefinedLiteralExpression +`-12_i +)txt", + R"txt( +IntegerUserDefinedLiteralExpression +`-12_r +)txt", + R"txt( +IntegerUserDefinedLiteralExpression +`-12_t +)txt"})); } TEST_P(SyntaxTreeTest, UserDefinedLiteral_Float) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( unsigned operator "" _f(long double); unsigned operator "" _r(const char*); @@ -1543,457 +1017,269 @@ template 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 + [[1.2_f]]; + [[1.2_r]]; + [[1.2_t]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-unsigned -| |-SimpleDeclarator -| | |-operator -| | |-"" -| | |-_f -| | `-ParametersAndQualifiers -| | |-( -| | |-SimpleDeclaration -| | | |-long -| | | `-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")); + {R"txt( +FloatUserDefinedLiteralExpression +`-1.2_f +)txt", + R"txt( +FloatUserDefinedLiteralExpression +`-1.2_r +)txt", + R"txt( +FloatUserDefinedLiteralExpression +`-1.2_t +)txt"})); } TEST_P(SyntaxTreeTest, IntegerLiteral_LongLong) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - 12ll; - 12ull; + [[12ll]]; + [[12ull]]; } )cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-IntegerLiteralExpression - | | `-12ll - | `-; - |-ExpressionStatement - | |-IntegerLiteralExpression - | | `-12ull - | `-; - `-} -)txt")); + {R"txt( +IntegerLiteralExpression +`-12ll +)txt", + R"txt( +IntegerLiteralExpression +`-12ull +)txt"})); } TEST_P(SyntaxTreeTest, IntegerLiteral_Binary) { if (!GetParam().isCXX14OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - 0b1100; + [[0b1100]]; } )cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-IntegerLiteralExpression - | | `-0b1100 - | `-; - `-} -)txt")); + {R"txt( +IntegerLiteralExpression +`-0b1100 +)txt"})); } TEST_P(SyntaxTreeTest, IntegerLiteral_WithDigitSeparators) { if (!GetParam().isCXX14OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - 1'2'0ull; + [[1'2'0ull]]; } )cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-IntegerLiteralExpression - | | `-1'2'0ull - | `-; - `-} -)txt")); + {R"txt( +IntegerLiteralExpression +`-1'2'0ull +)txt"})); } TEST_P(SyntaxTreeTest, CharacterLiteral) { - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - 'a'; - '\n'; - '\x20'; - '\0'; - L'a'; - L'α'; -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-'a' - | `-; - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-'\n' - | `-; - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-'\x20' - | `-; - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-'\0' - | `-; - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-L'a' - | `-; - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-L'α' - | `-; - `-} -)txt")); + [['a']]; + [['\n']]; + [['\x20']]; + [['\0']]; + [[L'a']]; + [[L'α']]; +} +)cpp", + {R"txt( +CharacterLiteralExpression +`-'a' +)txt", + R"txt( +CharacterLiteralExpression +`-'\n' +)txt", + R"txt( +CharacterLiteralExpression +`-'\x20' +)txt", + R"txt( +CharacterLiteralExpression +`-'\0' +)txt", + R"txt( +CharacterLiteralExpression +`-L'a' +)txt", + R"txt( +CharacterLiteralExpression +`-L'α' +)txt"})); } TEST_P(SyntaxTreeTest, CharacterLiteral_Utf) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - u'a'; - u'構'; - U'a'; - U'🌲'; -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-u'a' - | `-; - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-u'構' - | `-; - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-U'a' - | `-; - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-U'🌲' - | `-; - `-} -)txt")); + [[u'a']]; + [[u'構']]; + [[U'a']]; + [[U'🌲']]; +} +)cpp", + {R"txt( +CharacterLiteralExpression +`-u'a' +)txt", + R"txt( +CharacterLiteralExpression +`-u'構' +)txt", + R"txt( +CharacterLiteralExpression +`-U'a' +)txt", + R"txt( +CharacterLiteralExpression +`-U'🌲' +)txt"})); } TEST_P(SyntaxTreeTest, CharacterLiteral_Utf8) { if (!GetParam().isCXX17OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - u8'a'; - u8'\x7f'; + [[u8'a']]; + [[u8'\x7f']]; } )cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-u8'a' - | `-; - |-ExpressionStatement - | |-CharacterLiteralExpression - | | `-u8'\x7f' - | `-; - `-} -)txt")); + {R"txt( +CharacterLiteralExpression +`-u8'a' +)txt", + R"txt( +CharacterLiteralExpression +`-u8'\x7f' +)txt"})); } TEST_P(SyntaxTreeTest, FloatingLiteral) { - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - 1e-2; - 2.; - .2; - 2.f; -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-FloatingLiteralExpression - | | `-1e-2 - | `-; - |-ExpressionStatement - | |-FloatingLiteralExpression - | | `-2. - | `-; - |-ExpressionStatement - | |-FloatingLiteralExpression - | | `-.2 - | `-; - |-ExpressionStatement - | |-FloatingLiteralExpression - | | `-2.f - | `-; - `-} -)txt")); + [[1e-2]]; + [[2.]]; + [[.2]]; + [[2.f]]; +} +)cpp", + {R"txt( +FloatingLiteralExpression +`-1e-2 +)txt", + R"txt( +FloatingLiteralExpression +`-2. +)txt", + R"txt( +FloatingLiteralExpression +`-.2 +)txt", + R"txt( +FloatingLiteralExpression +`-2.f +)txt"})); } TEST_P(SyntaxTreeTest, FloatingLiteral_Hexadecimal) { if (!GetParam().isCXX17OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( + R"cpp( +void test() { + [[0xfp1]]; + [[0xf.p1]]; + [[0x.fp1]]; + [[0xf.fp1f]]; +} +)cpp", + {R"txt( +FloatingLiteralExpression +`-0xfp1 +)txt", + R"txt( +FloatingLiteralExpression +`-0xf.p1 +)txt", + R"txt( +FloatingLiteralExpression +`-0x.fp1 +)txt", + R"txt( +FloatingLiteralExpression +`-0xf.fp1f +)txt"})); +} + +TEST_P(SyntaxTreeTest, StringLiteral) { + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - 0xfp1; - 0xf.p1; - 0x.fp1; - 0xf.fp1f; + [["a\n\0\x20"]]; + [[L"αβ"]]; } )cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-FloatingLiteralExpression - | | `-0xfp1 - | `-; - |-ExpressionStatement - | |-FloatingLiteralExpression - | | `-0xf.p1 - | `-; - |-ExpressionStatement - | |-FloatingLiteralExpression - | | `-0x.fp1 - | `-; - |-ExpressionStatement - | |-FloatingLiteralExpression - | | `-0xf.fp1f - | `-; - `-} -)txt")); -} - -TEST_P(SyntaxTreeTest, StringLiteral) { - EXPECT_TRUE(treeDumpEqual( - R"cpp( -void test() { - "a\n\0\x20"; - L"αβ"; -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-StringLiteralExpression - | | `-"a\n\0\x20" - | `-; - |-ExpressionStatement - | |-StringLiteralExpression - | | `-L"αβ" - | `-; - `-} -)txt")); + {R"txt( +StringLiteralExpression +`-"a\n\0\x20" +)txt", + R"txt( +StringLiteralExpression +`-L"αβ" +)txt"})); } TEST_P(SyntaxTreeTest, StringLiteral_Utf) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - u8"a\x1f\x05"; - u"C++抽象構文木"; - U"📖🌲\n"; + [[u8"a\x1f\x05"]]; + [[u"C++抽象構文木"]]; + [[U"📖🌲\n"]]; } )cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-StringLiteralExpression - | | `-u8"a\x1f\x05" - | `-; - |-ExpressionStatement - | |-StringLiteralExpression - | | `-u"C++抽象構文木" - | `-; - |-ExpressionStatement - | |-StringLiteralExpression - | | `-U"📖🌲\n" - | `-; - `-} -)txt")); + {R"txt( +StringLiteralExpression +`-u8"a\x1f\x05" +)txt", + R"txt( +StringLiteralExpression +`-u"C++抽象構文木" +)txt", + R"txt( +StringLiteralExpression +`-U"📖🌲\n" +)txt"})); } TEST_P(SyntaxTreeTest, StringLiteral_Raw) { @@ -2033,1221 +1319,646 @@ TEST_P(SyntaxTreeTest, BoolLiteral) { if (GetParam().isC()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - true; - false; + [[true]]; + [[false]]; } )cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-BoolLiteralExpression - | | `-true - | `-; - |-ExpressionStatement - | |-BoolLiteralExpression - | | `-false - | `-; - `-} -)txt")); + {R"txt( +BoolLiteralExpression +`-true +)txt", + R"txt( +BoolLiteralExpression +`-false +)txt"})); } TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) { if (!GetParam().isCXX11OrLater()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - nullptr; + [[nullptr]]; } )cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-CxxNullPtrExpression - | | `-nullptr - | `-; - `-} -)txt")); + {R"txt( +CxxNullPtrExpression +`-nullptr +)txt"})); } TEST_P(SyntaxTreeTest, PostfixUnaryOperator) { - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test(int a) { - a++; - a--; -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-int - | | `-SimpleDeclarator - | | `-a - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-PostfixUnaryOperatorExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-a - | | `-++ - | `-; - |-ExpressionStatement - | |-PostfixUnaryOperatorExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-a - | | `--- - | `-; - `-} -)txt")); + [[a++]]; + [[a--]]; +} +)cpp", + {R"txt( +PostfixUnaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-a +`-++ +)txt", + R"txt( +PostfixUnaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-a +`--- +)txt"})); } TEST_P(SyntaxTreeTest, PrefixUnaryOperator) { - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test(int a, int *ap) { - --a; ++a; - ~a; - -a; - +a; - &a; - *ap; - !a; - __real a; __imag a; -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-int - | | `-SimpleDeclarator - | | `-a - | |-, - | |-SimpleDeclaration - | | |-int - | | `-SimpleDeclarator - | | |-* - | | `-ap - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |--- - | | `-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-++ - | | `-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-~ - | | `-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-- - | | `-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-+ - | | `-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-& - | | `-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-* - | | `-IdExpression - | | `-UnqualifiedId - | | `-ap - | `-; - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-! - | | `-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-__real - | | `-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-__imag - | | `-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - `-} -)txt")); + [[--a]]; [[++a]]; + [[~a]]; + [[-a]]; + [[+a]]; + [[&a]]; + [[*ap]]; + [[!a]]; + [[__real a]]; [[__imag a]]; +} +)cpp", + {R"txt( +PrefixUnaryOperatorExpression +|--- +`-IdExpression + `-UnqualifiedId + `-a +)txt", + R"txt( +PrefixUnaryOperatorExpression +|-++ +`-IdExpression + `-UnqualifiedId + `-a +)txt", + R"txt( +PrefixUnaryOperatorExpression +|-~ +`-IdExpression + `-UnqualifiedId + `-a +)txt", + R"txt( +PrefixUnaryOperatorExpression +|-- +`-IdExpression + `-UnqualifiedId + `-a +)txt", + R"txt( +PrefixUnaryOperatorExpression +|-+ +`-IdExpression + `-UnqualifiedId + `-a +)txt", + R"txt( +PrefixUnaryOperatorExpression +|-& +`-IdExpression + `-UnqualifiedId + `-a +)txt", + R"txt( +PrefixUnaryOperatorExpression +|-* +`-IdExpression + `-UnqualifiedId + `-ap +)txt", + R"txt( +PrefixUnaryOperatorExpression +|-! +`-IdExpression + `-UnqualifiedId + `-a +)txt", + R"txt( +PrefixUnaryOperatorExpression +|-__real +`-IdExpression + `-UnqualifiedId + `-a +)txt", + R"txt( +PrefixUnaryOperatorExpression +|-__imag +`-IdExpression + `-UnqualifiedId + `-a +)txt"})); } TEST_P(SyntaxTreeTest, PrefixUnaryOperatorCxx) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test(int a, bool b) { - compl a; - not b; -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-int - | | `-SimpleDeclarator - | | `-a - | |-, - | |-SimpleDeclaration - | | |-bool - | | `-SimpleDeclarator - | | `-b - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-compl - | | `-IdExpression - | | `-UnqualifiedId - | | `-a - | `-; - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-not - | | `-IdExpression - | | `-UnqualifiedId - | | `-b - | `-; - `-} -)txt")); + [[compl a]]; + [[not b]]; +} +)cpp", + {R"txt( +PrefixUnaryOperatorExpression +|-compl +`-IdExpression + `-UnqualifiedId + `-a +)txt", + R"txt( +PrefixUnaryOperatorExpression +|-not +`-IdExpression + `-UnqualifiedId + `-b +)txt"})); } TEST_P(SyntaxTreeTest, BinaryOperator) { - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test(int a) { - 1 - 2; - 1 == 2; - a = 1; - a <<= 1; - 1 || 0; - 1 & 2; - a ^= 3; -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-int - | | `-SimpleDeclarator - | | `-a - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IntegerLiteralExpression - | | | `-1 - | | |-- - | | `-IntegerLiteralExpression - | | `-2 - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IntegerLiteralExpression - | | | `-1 - | | |-== - | | `-IntegerLiteralExpression - | | `-2 - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-a - | | |-= - | | `-IntegerLiteralExpression - | | `-1 - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-a - | | |-<<= - | | `-IntegerLiteralExpression - | | `-1 - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IntegerLiteralExpression - | | | `-1 - | | |-|| - | | `-IntegerLiteralExpression - | | `-0 - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IntegerLiteralExpression - | | | `-1 - | | |-& - | | `-IntegerLiteralExpression - | | `-2 - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-a - | | |-^= - | | `-IntegerLiteralExpression - | | `-3 - | `-; - `-} -)txt")); + [[1 - 2]]; + [[1 == 2]]; + [[a = 1]]; + [[a <<= 1]]; + [[1 || 0]]; + [[1 & 2]]; + [[a != 3]]; +} +)cpp", + {R"txt( +BinaryOperatorExpression +|-IntegerLiteralExpression +| `-1 +|-- +`-IntegerLiteralExpression + `-2 +)txt", + R"txt( +BinaryOperatorExpression +|-IntegerLiteralExpression +| `-1 +|-== +`-IntegerLiteralExpression + `-2 +)txt", + R"txt( +BinaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-a +|-= +`-IntegerLiteralExpression + `-1 +)txt", + R"txt( +BinaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-a +|-<<= +`-IntegerLiteralExpression + `-1 +)txt", + R"txt( +BinaryOperatorExpression +|-IntegerLiteralExpression +| `-1 +|-|| +`-IntegerLiteralExpression + `-0 +)txt", + R"txt( +BinaryOperatorExpression +|-IntegerLiteralExpression +| `-1 +|-& +`-IntegerLiteralExpression + `-2 +)txt", + R"txt( +BinaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-a +|-!= +`-IntegerLiteralExpression + `-3 +)txt"})); } TEST_P(SyntaxTreeTest, BinaryOperatorCxx) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test(int a) { - true || false; - true or false; - 1 bitand 2; - a xor_eq 3; -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-int - | | `-SimpleDeclarator - | | `-a - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-BoolLiteralExpression - | | | `-true - | | |-|| - | | `-BoolLiteralExpression - | | `-false - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-BoolLiteralExpression - | | | `-true - | | |-or - | | `-BoolLiteralExpression - | | `-false - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IntegerLiteralExpression - | | | `-1 - | | |-bitand - | | `-IntegerLiteralExpression - | | `-2 - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-a - | | |-xor_eq - | | `-IntegerLiteralExpression - | | `-3 - | `-; - `-} -)txt")); + [[true || false]]; + [[true or false]]; + [[1 bitand 2]]; + [[a xor_eq 3]]; +} +)cpp", + {R"txt( +BinaryOperatorExpression +|-BoolLiteralExpression +| `-true +|-|| +`-BoolLiteralExpression + `-false +)txt", + R"txt( +BinaryOperatorExpression +|-BoolLiteralExpression +| `-true +|-or +`-BoolLiteralExpression + `-false +)txt", + R"txt( +BinaryOperatorExpression +|-IntegerLiteralExpression +| `-1 +|-bitand +`-IntegerLiteralExpression + `-2 +)txt", + R"txt( +BinaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-a +|-xor_eq +`-IntegerLiteralExpression + `-3 +)txt"})); } TEST_P(SyntaxTreeTest, BinaryOperator_NestedWithParenthesis) { - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - (1 + 2) * (4 / 2); + [[(1 + 2) * (4 / 2)]]; } )cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-ParenExpression - | | | |-( - | | | |-BinaryOperatorExpression - | | | | |-IntegerLiteralExpression - | | | | | `-1 - | | | | |-+ - | | | | `-IntegerLiteralExpression - | | | | `-2 - | | | `-) - | | |-* - | | `-ParenExpression - | | |-( - | | |-BinaryOperatorExpression - | | | |-IntegerLiteralExpression - | | | | `-4 - | | | |-/ - | | | `-IntegerLiteralExpression - | | | `-2 - | | `-) - | `-; - `-} -)txt")); + {R"txt( +BinaryOperatorExpression +|-ParenExpression +| |-( +| |-BinaryOperatorExpression +| | |-IntegerLiteralExpression +| | | `-1 +| | |-+ +| | `-IntegerLiteralExpression +| | `-2 +| `-) +|-* +`-ParenExpression + |-( + |-BinaryOperatorExpression + | |-IntegerLiteralExpression + | | `-4 + | |-/ + | `-IntegerLiteralExpression + | `-2 + `-) +)txt"})); } TEST_P(SyntaxTreeTest, BinaryOperator_Associativity) { - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( 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 - | |-BinaryOperatorExpression - | | |-BinaryOperatorExpression - | | | |-IdExpression - | | | | `-UnqualifiedId - | | | | `-a - | | | |-+ - | | | `-IdExpression - | | | `-UnqualifiedId - | | | `-b - | | |-+ - | | `-IntegerLiteralExpression - | | `-42 - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-a - | | |-= - | | `-BinaryOperatorExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-b - | | |-= - | | `-IntegerLiteralExpression - | | `-42 - | `-; - `-} -)txt")); + [[a + b + 42]]; + [[a = b = 42]]; +} +)cpp", + {R"txt( +BinaryOperatorExpression +|-BinaryOperatorExpression +| |-IdExpression +| | `-UnqualifiedId +| | `-a +| |-+ +| `-IdExpression +| `-UnqualifiedId +| `-b +|-+ +`-IntegerLiteralExpression + `-42 +)txt", + R"txt( +BinaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-a +|-= +`-BinaryOperatorExpression + |-IdExpression + | `-UnqualifiedId + | `-b + |-= + `-IntegerLiteralExpression + `-42 +)txt"})); } TEST_P(SyntaxTreeTest, BinaryOperator_Precedence) { - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( void test() { - 1 + 2 * 3 + 4; - 1 % 2 + 3 * 4; -} -)cpp", - R"txt( -*: TranslationUnit -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-BinaryOperatorExpression - | | | |-IntegerLiteralExpression - | | | | `-1 - | | | |-+ - | | | `-BinaryOperatorExpression - | | | |-IntegerLiteralExpression - | | | | `-2 - | | | |-* - | | | `-IntegerLiteralExpression - | | | `-3 - | | |-+ - | | `-IntegerLiteralExpression - | | `-4 - | `-; - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-BinaryOperatorExpression - | | | |-IntegerLiteralExpression - | | | | `-1 - | | | |-% - | | | `-IntegerLiteralExpression - | | | `-2 - | | |-+ - | | `-BinaryOperatorExpression - | | |-IntegerLiteralExpression - | | | `-3 - | | |-* - | | `-IntegerLiteralExpression - | | `-4 - | `-; - `-} -)txt")); + [[1 + 2 * 3 + 4]]; + [[1 % 2 + 3 * 4]]; +} +)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_Assignment) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { X& operator=(const X&); }; void test(X x, X y) { - x = y; + [[x = y]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-SimpleDeclaration -| | |-X -| | |-SimpleDeclarator -| | | |-& -| | | |-operator -| | | |-= -| | | `-ParametersAndQualifiers -| | | |-( -| | | |-SimpleDeclaration -| | | | |-const -| | | | |-X -| | | | `-SimpleDeclarator -| | | | `-& -| | | `-) -| | `-; -| |-} -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-X - | | `-SimpleDeclarator - | | `-x - | |-, - | |-SimpleDeclaration - | | |-X - | | `-SimpleDeclarator - | | `-y - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-BinaryOperatorExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-x - | | |-= - | | `-IdExpression - | | `-UnqualifiedId - | | `-y - | `-; - `-} -)txt")); + {R"txt( +BinaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-x +|-= +`-IdExpression + `-UnqualifiedId + `-y +)txt"})); } TEST_P(SyntaxTreeTest, OverloadedOperator_Plus) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { friend X operator+(X, const X&); }; void test(X x, X y) { - x + y; + [[x + y]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-UnknownDeclaration -| | `-SimpleDeclaration -| | |-friend -| | |-X -| | |-SimpleDeclarator -| | | |-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")); + {R"txt( +BinaryOperatorExpression +|-UnknownExpression +| `-IdExpression +| `-UnqualifiedId +| `-x +|-+ +`-IdExpression + `-UnqualifiedId + `-y +)txt"})); } TEST_P(SyntaxTreeTest, OverloadedOperator_Less) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { friend bool operator<(const X&, const X&); }; void test(X x, X y) { - x < y; + [[x < y]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-UnknownDeclaration -| | `-SimpleDeclaration -| | |-friend -| | |-bool -| | |-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")); + {R"txt( +BinaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-x +|-< +`-IdExpression + `-UnqualifiedId + `-y +)txt"})); } TEST_P(SyntaxTreeTest, OverloadedOperator_LeftShift) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { friend X operator<<(X&, const X&); }; void test(X x, X y) { - x << y; + [[x << y]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-UnknownDeclaration -| | `-SimpleDeclaration -| | |-friend -| | |-X -| | |-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")); + {R"txt( +BinaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-x +|-<< +`-IdExpression + `-UnqualifiedId + `-y +)txt"})); } TEST_P(SyntaxTreeTest, OverloadedOperator_Comma) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { X operator,(X&); }; void test(X x, X y) { - x, y; + [[x, y]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-SimpleDeclaration -| | |-X -| | |-SimpleDeclarator -| | | |-operator -| | | |-, -| | | `-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")); + {R"txt( +BinaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-x +|-, +`-IdExpression + `-UnqualifiedId + `-y +)txt"})); } TEST_P(SyntaxTreeTest, OverloadedOperator_PointerToMember) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { X operator->*(int); }; void test(X* xp, int X::* pmi) { - xp->*pmi; + [[xp->*pmi]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-SimpleDeclaration -| | |-X -| | |-SimpleDeclarator -| | | |-operator -| | | |-->* -| | | `-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")); + {R"txt( +BinaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-xp +|-->* +`-IdExpression + `-UnqualifiedId + `-pmi +)txt"})); } TEST_P(SyntaxTreeTest, OverloadedOperator_Negation) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { bool operator!(); }; void test(X x) { - !x; + [[!x]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-SimpleDeclaration -| | |-bool -| | |-SimpleDeclarator -| | | |-operator -| | | |-! -| | | `-ParametersAndQualifiers -| | | |-( -| | | `-) -| | `-; -| |-} -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-X - | | `-SimpleDeclarator - | | `-x - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-! - | | `-IdExpression - | | `-UnqualifiedId - | | `-x - | `-; - `-} -)txt")); + {R"txt( +PrefixUnaryOperatorExpression +|-! +`-IdExpression + `-UnqualifiedId + `-x +)txt"})); } TEST_P(SyntaxTreeTest, OverloadedOperator_AddressOf) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { X* operator&(); }; void test(X x) { - &x; + [[&x]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-SimpleDeclaration -| | |-X -| | |-SimpleDeclarator -| | | |-* -| | | |-operator -| | | |-& -| | | `-ParametersAndQualifiers -| | | |-( -| | | `-) -| | `-; -| |-} -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-X - | | `-SimpleDeclarator - | | `-x - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-& - | | `-IdExpression - | | `-UnqualifiedId - | | `-x - | `-; - `-} -)txt")); + {R"txt( +PrefixUnaryOperatorExpression +|-& +`-IdExpression + `-UnqualifiedId + `-x +)txt"})); } TEST_P(SyntaxTreeTest, OverloadedOperator_PrefixIncrement) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { X operator++(); }; void test(X x) { - ++x; + [[++x]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-SimpleDeclaration -| | |-X -| | |-SimpleDeclarator -| | | |-operator -| | | |-++ -| | | `-ParametersAndQualifiers -| | | |-( -| | | `-) -| | `-; -| |-} -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-X - | | `-SimpleDeclarator - | | `-x - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-PrefixUnaryOperatorExpression - | | |-++ - | | `-IdExpression - | | `-UnqualifiedId - | | `-x - | `-; - `-} -)txt")); + {R"txt( +PrefixUnaryOperatorExpression +|-++ +`-IdExpression + `-UnqualifiedId + `-x +)txt"})); } TEST_P(SyntaxTreeTest, OverloadedOperator_PostfixIncrement) { if (!GetParam().isCXX()) { return; } - EXPECT_TRUE(treeDumpEqual( + EXPECT_TRUE(treeDumpEqualOnAnnotations( R"cpp( struct X { X operator++(int); }; void test(X x) { - x++; + [[x++]]; } )cpp", - R"txt( -*: TranslationUnit -|-SimpleDeclaration -| |-struct -| |-X -| |-{ -| |-SimpleDeclaration -| | |-X -| | |-SimpleDeclarator -| | | |-operator -| | | |-++ -| | | `-ParametersAndQualifiers -| | | |-( -| | | |-SimpleDeclaration -| | | | `-int -| | | `-) -| | `-; -| |-} -| `-; -`-SimpleDeclaration - |-void - |-SimpleDeclarator - | |-test - | `-ParametersAndQualifiers - | |-( - | |-SimpleDeclaration - | | |-X - | | `-SimpleDeclarator - | | `-x - | `-) - `-CompoundStatement - |-{ - |-ExpressionStatement - | |-PostfixUnaryOperatorExpression - | | |-IdExpression - | | | `-UnqualifiedId - | | | `-x - | | `-++ - | `-; - `-} -)txt")); + {R"txt( +PostfixUnaryOperatorExpression +|-IdExpression +| `-UnqualifiedId +| `-x +`-++ +)txt"})); } TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) { @@ -3343,6 +2054,33 @@ void foo() { )txt")); } +TEST_P(SyntaxTreeTest, SizeTTypedef) { + if (!GetParam().isCXX11OrLater()) { + return; + } + EXPECT_TRUE(treeDumpEqual( + R"cpp( +typedef decltype(sizeof(void *)) size_t; + )cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-typedef + |-decltype + |-( + |-UnknownExpression + | |-sizeof + | |-( + | |-void + | |-* + | `-) + |-) + |-SimpleDeclarator + | `-size_t + `-; +)txt")); +} + TEST_P(SyntaxTreeTest, Namespaces) { if (!GetParam().isCXX()) { return; @@ -3496,68 +2234,318 @@ struct {} *a1; )txt")); } -TEST_P(SyntaxTreeTest, Templates) { +TEST_P(SyntaxTreeTest, StaticMemberFunction) { + if (!GetParam().isCXX11OrLater()) { + return; + } + EXPECT_TRUE(treeDumpEqual( + R"cpp( +struct S { + static void f(){} +}; +)cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-struct + |-S + |-{ + |-SimpleDeclaration + | |-static + | |-void + | |-SimpleDeclarator + | | |-f + | | `-ParametersAndQualifiers + | | |-( + | | `-) + | `-CompoundStatement + | |-{ + | `-} + |-} + `-; +)txt")); +} + +TEST_P(SyntaxTreeTest, ConversionMemberFunction) { if (!GetParam().isCXX()) { return; } - if (GetParam().hasDelayedTemplateParsing()) { - // FIXME: Make this test work on Windows by generating the expected syntax - // tree when `-fdelayed-template-parsing` is active. + EXPECT_TRUE(treeDumpEqual( + R"cpp( +struct X { + operator int(); +}; +)cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-struct + |-X + |-{ + |-SimpleDeclaration + | |-SimpleDeclarator + | | |-operator + | | |-int + | | `-ParametersAndQualifiers + | | |-( + | | `-) + | `-; + |-} + `-; +)txt")); +} + +TEST_P(SyntaxTreeTest, LiteralOperatorDeclaration) { + if (!GetParam().isCXX11OrLater()) { + return; + } + EXPECT_TRUE(treeDumpEqual( + R"cpp( +unsigned operator "" _c(char); + )cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-unsigned + |-SimpleDeclarator + | |-operator + | |-"" + | |-_c + | `-ParametersAndQualifiers + | |-( + | |-SimpleDeclaration + | | `-char + | `-) + `-; +)txt")); +} + +TEST_P(SyntaxTreeTest, NumericLiteralOperatorTemplateDeclaration) { + if (!GetParam().isCXX11OrLater()) { + return; + } + EXPECT_TRUE(treeDumpEqual( + R"cpp( +template +unsigned operator "" _t(); + )cpp", + R"txt( +*: TranslationUnit +`-TemplateDeclaration + |-template + |-< + |-SimpleDeclaration + | `-char + |-... + |-> + `-SimpleDeclaration + |-unsigned + |-SimpleDeclarator + | |-operator + | |-"" + | |-_t + | `-ParametersAndQualifiers + | |-( + | `-) + `-; +)txt")); +} + +TEST_P(SyntaxTreeTest, OverloadedOperatorDeclaration) { + if (!GetParam().isCXX()) { return; } EXPECT_TRUE(treeDumpEqual( R"cpp( -template struct cls {}; -template int var = 10; -template int fun() {} +struct X { + X& operator=(const X&); +}; +)cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-struct + |-X + |-{ + |-SimpleDeclaration + | |-X + | |-SimpleDeclarator + | | |-& + | | |-operator + | | |-= + | | `-ParametersAndQualifiers + | | |-( + | | |-SimpleDeclaration + | | | |-const + | | | |-X + | | | `-SimpleDeclarator + | | | `-& + | | `-) + | `-; + |-} + `-; +)txt")); +} + +TEST_P(SyntaxTreeTest, OverloadedOperatorFriendDeclarataion) { + if (!GetParam().isCXX()) { + return; + } + EXPECT_TRUE(treeDumpEqual( + R"cpp( +struct X { + friend X operator+(X, const X&); +}; +)cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-struct + |-X + |-{ + |-UnknownDeclaration + | `-SimpleDeclaration + | |-friend + | |-X + | |-SimpleDeclarator + | | |-operator + | | |-+ + | | `-ParametersAndQualifiers + | | |-( + | | |-SimpleDeclaration + | | | `-X + | | |-, + | | |-SimpleDeclaration + | | | |-const + | | | |-X + | | | `-SimpleDeclarator + | | | `-& + | | `-) + | `-; + |-} + `-; +)txt")); +} + +TEST_P(SyntaxTreeTest, ClassTemplateDeclaration) { + if (!GetParam().isCXX()) { + return; + } + EXPECT_TRUE(treeDumpEqual( + R"cpp( +template +struct ST {}; )cpp", R"txt( *: TranslationUnit -|-TemplateDeclaration -| |-template -| |-< -| |-UnknownDeclaration -| | |-class -| | `-T -| |-> -| `-SimpleDeclaration -| |-struct -| |-cls -| |-{ -| |-} -| `-; -|-TemplateDeclaration -| |-template -| |-< -| |-UnknownDeclaration -| | |-class -| | `-T -| |-> -| `-SimpleDeclaration -| |-int -| |-SimpleDeclarator -| | |-var -| | |-= -| | `-IntegerLiteralExpression -| | `-10 -| `-; `-TemplateDeclaration |-template |-< |-UnknownDeclaration - | |-class + | |-typename + | `-T + |-> + `-SimpleDeclaration + |-struct + |-ST + |-{ + |-} + `-; +)txt")); +} + +TEST_P(SyntaxTreeTest, FunctionTemplateDeclaration) { + if (!GetParam().isCXX()) { + return; + } + EXPECT_TRUE(treeDumpEqual( + R"cpp( +template +T f(); +)cpp", + R"txt( +*: TranslationUnit +`-TemplateDeclaration + |-template + |-< + |-UnknownDeclaration + | |-typename | `-T |-> `-SimpleDeclaration - |-int + |-T |-SimpleDeclarator - | |-fun + | |-f | `-ParametersAndQualifiers | |-( | `-) - `-CompoundStatement - |-{ - `-} + `-; +)txt")); +} + +TEST_P(SyntaxTreeTest, VariableTemplateDeclaration) { + if (!GetParam().isCXX()) { + return; + } + EXPECT_TRUE(treeDumpEqual( + R"cpp( +template T var = 10; +)cpp", + R"txt( +*: TranslationUnit +`-TemplateDeclaration + |-template + |-< + |-UnknownDeclaration + | |-class + | `-T + |-> + `-SimpleDeclaration + |-T + |-SimpleDeclarator + | |-var + | |-= + | `-IntegerLiteralExpression + | `-10 + `-; +)txt")); +} + +TEST_P(SyntaxTreeTest, StaticMemberFunctionTemplate) { + if (!GetParam().isCXX()) { + return; + } + EXPECT_TRUE(treeDumpEqual( + R"cpp( +struct S { + template + static U f(); +}; +)cpp", + R"txt( +*: TranslationUnit +`-SimpleDeclaration + |-struct + |-S + |-{ + |-TemplateDeclaration + | |-template + | |-< + | |-UnknownDeclaration + | | |-typename + | | `-U + | |-> + | `-SimpleDeclaration + | |-static + | |-U + | |-SimpleDeclarator + | | |-f + | | `-ParametersAndQualifiers + | | |-( + | | `-) + | `-; + |-} + `-; )txt")); } @@ -3606,6 +2594,59 @@ struct X { )txt")); } +TEST_P(SyntaxTreeTest, NestedTemplatesInNamespace) { + if (!GetParam().isCXX()) { + return; + } + EXPECT_TRUE(treeDumpEqual( + R"cpp( +namespace n { + template + struct ST { + template + static U f(); + }; +} +)cpp", + R"txt( +*: TranslationUnit +`-NamespaceDefinition + |-namespace + |-n + |-{ + |-TemplateDeclaration + | |-template + | |-< + | |-UnknownDeclaration + | | |-typename + | | `-T + | |-> + | `-SimpleDeclaration + | |-struct + | |-ST + | |-{ + | |-TemplateDeclaration + | | |-template + | | |-< + | | |-UnknownDeclaration + | | | |-typename + | | | `-U + | | |-> + | | `-SimpleDeclaration + | | |-static + | | |-U + | | |-SimpleDeclarator + | | | |-f + | | | `-ParametersAndQualifiers + | | | |-( + | | | `-) + | | `-; + | |-} + | `-; + `-} +)txt")); +} + TEST_P(SyntaxTreeTest, Templates2) { if (!GetParam().isCXX()) { return; diff --git a/clang/unittests/Tooling/Syntax/TreeTestBase.cpp b/clang/unittests/Tooling/Syntax/TreeTestBase.cpp index 05fbac4..c5dbb77 100644 --- a/clang/unittests/Tooling/Syntax/TreeTestBase.cpp +++ b/clang/unittests/Tooling/Syntax/TreeTestBase.cpp @@ -171,7 +171,7 @@ SyntaxTreeTest::buildTree(StringRef Code, const TestClangConfig &ClangConfig) { << "Source file has syntax errors, they were printed to the test " "log"; } - std::string Actual = std::string(StringRef(Root->dump(*Arena)).trim()); + auto Actual = StringRef(Root->dump(*Arena)).trim().str(); // EXPECT_EQ shows the diff between the two strings if they are different. EXPECT_EQ(Tree.trim().str(), Actual); if (Actual != Tree.trim().str()) { @@ -194,21 +194,29 @@ SyntaxTreeTest::treeDumpEqualOnAnnotations(StringRef CodeWithAnnotations, "log"; } - bool failed = false; auto AnnotatedRanges = AnnotatedCode.ranges(); - assert(AnnotatedRanges.size() == TreeDumps.size()); - for (auto i = 0ul; i < AnnotatedRanges.size(); i++) { + if (AnnotatedRanges.size() != TreeDumps.size()) { + return ::testing::AssertionFailure() + << "The number of annotated ranges in the source code is different " + "to the number of their corresponding tree dumps."; + } + bool Failed = false; + for (unsigned i = 0; i < AnnotatedRanges.size(); i++) { auto *AnnotatedNode = nodeByRange(AnnotatedRanges[i], Root); assert(AnnotatedNode); auto AnnotatedNodeDump = - std::string(StringRef(AnnotatedNode->dump(*Arena)).trim()); + StringRef(AnnotatedNode->dump(*Arena)).trim().str(); // EXPECT_EQ shows the diff between the two strings if they are different. - EXPECT_EQ(TreeDumps[i].trim().str(), AnnotatedNodeDump); + EXPECT_EQ(TreeDumps[i].trim().str(), AnnotatedNodeDump) + << "Dumps diverged for the code:\n" + << AnnotatedCode.code().slice(AnnotatedRanges[i].Begin, + AnnotatedRanges[i].End); if (AnnotatedNodeDump != TreeDumps[i].trim().str()) - failed = true; + Failed = true; } - return failed ? ::testing::AssertionFailure() : ::testing::AssertionSuccess(); + return Failed ? ::testing::AssertionFailure() : ::testing::AssertionSuccess(); } + syntax::Node *SyntaxTreeTest::nodeByRange(llvm::Annotations::Range R, syntax::Node *Root) { ArrayRef Toks = tokens(Root); -- 2.7.4