[SyntaxTree] Split tests

[eduucaldas]

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.

[eduucaldas]

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

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

[eduucaldas]

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

[eduucaldas]

• [SyntaxTree] Split tests for QualifiedId

[eduucaldas]

Rename tests following TestSuite_TestCase

[eduucaldas]

clang/unittests/Tooling/Syntax/TreeTest.cpp

635

Last commit change names to TestSuite_TestCase

1153

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

1539–1541

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

[gribozavr2]

Please also consider splitting the file into multiple.

clang/unittests/Tooling/Syntax/TreeTest.cpp

1202

Indent -2.

1310

For consistency with other test names: QualifiedId_DecltypeSpecifier

2437

BinaryOperator_NestedWithParenthesis

2494

BinaryOperator_Associativity

2538

BinaryOperator_Precedence

2558

UserDefinedOperator => OverloadedOperator?

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

2679

UserDefinedOperator_LeftShift

2713

UserDefinedOperator_PointerToMember

2790

PrefixIncrement

2848

UserDefinedOperator_Negation

2881

PostfixIncrement

Also, group it right after prefix increment?

[eduucaldas]

Answer review comments

clang/unittests/Tooling/Syntax/TreeTest.cpp

2558

Actually it is a very good point! Thanks!

2881

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]

clang/unittests/Tooling/Syntax/TreeTest.cpp

1539–1541

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

[eduucaldas]

We'll split this file in a future change

clang/unittests/Tooling/Syntax/TreeTest.cpp

`-CompoundStatement
     |   | |   `-test
     |   | |-(
     |   | `-)
     |   `-;
     `-}
 )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) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {
-  // TODO: Expose `id-expression` from `Declarator`
   friend X operator+(const X&, const X&);
-  operator int();
 };
-template<typename T>
-void f(T&);
 void test(X x) {
-  x;                      // identifier
-  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
+  operator+(x, x);
 }
 )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-X
 | |-{

 | |   |   |-,
 | |   |   |-SimpleDeclaration
 | |   |   | |-const
 | |   |   | |-X
 | |   |   | `-SimpleDeclarator
 | |   |   |   `-&
 | |   |   `-)
 | |   `-;
-| |-SimpleDeclaration
-| | |-SimpleDeclarator
-| | | |-operator
-| | | |-int
-| | | `-ParametersAndQualifiers
-| | |   |-(
-| | |   `-)
-| | `-;
 | |-}
 | `-;
-|-TemplateDeclaration
-| |-template
-| |-<
-| |-UnknownDeclaration
-| | |-typename
-| | `-T
-| |->
-| `-SimpleDeclaration
-|   |-void
-|   |-SimpleDeclarator
-|   | |-f
-|   | `-ParametersAndQualifiers
-|   |   |-(
-|   |   |-SimpleDeclaration
-|   |   | |-T
-|   |   | `-SimpleDeclarator
-|   |   |   `-&
-|   |   `-)
-|   `-;
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-X
   |   | `-SimpleDeclarator
   |   |   `-x
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
-    | |-IdExpression
-    | | `-UnqualifiedId
-    | |   `-x
-    | `-;
-    |-ExpressionStatement
     | |-UnknownExpression
     | | |-IdExpression
     | | | `-UnqualifiedId
     | | |   |-operator
     | | |   `-+
     | | |-(
     | | |-IdExpression
     | | | `-UnqualifiedId
     | | |   `-x
     | | |-,
     | | |-IdExpression
     | | | `-UnqualifiedId
     | | |   `-x
     | | `-)
     | `-;
-    |-ExpressionStatement
-    | |-UnknownExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   |-f
-    | | |   |-<
-    | | |   |-X
-    | | |   `->
-    | | |-(
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   `-x
-    | | `-)
-    | `-;
+    `-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, UnqualifiedIdConversionFunctionId) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+      R"cpp(
+struct 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
     | |-UnknownExpression
     | | |-UnknownExpression
     | | | |-IdExpression
     | | | | `-UnqualifiedId
     | | | |   `-x
     | | | |-.
     | | | |-operator
     | | | `-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
     | |-UnknownExpression
     | | |-UnknownExpression
     | | | |-IdExpression
     | | | | `-UnqualifiedId
     | | | |   `-x
     | | | |-.
     | | | |-~
     | | | `-X
     | | |-(
     | | `-)
     | `-;
     `-}
 )txt"));
 }
 
-TEST_P(SyntaxTreeTest, UnqualifiedIdCxx11OrLater) {
+TEST_P(SyntaxTreeTest, UnqualifiedIdDecltypeDestructor) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X { };
-unsigned operator "" _w(long long unsigned);
 void test(X x) {
-  operator "" _w(1llu);   // literal-operator-id
   // TODO: Expose `id-expression` from `MemberExpr`
-  x.~decltype(x)();       // ~decltype-specifier
+  x.~decltype(x)();
 }
 )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-X
 | |-{
 | |-}
 | `-;
-|-SimpleDeclaration
-| |-unsigned
-| |-SimpleDeclarator
-| | |-operator
-| | |-""
-| | |-_w
-| | `-ParametersAndQualifiers
-| |   |-(
-| |   |-SimpleDeclaration
-| |   | |-long
-| |   | |-long
-| |   | `-unsigned
-| |   `-)
-| `-;
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-X
   |   | `-SimpleDeclarator
   |   |   `-x
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-UnknownExpression
-    | | |-IdExpression
-    | | | `-UnqualifiedId
-    | | |   |-operator
-    | | |   |-""
-    | | |   `-_w
-    | | |-(
-    | | |-IntegerLiteralExpression
-    | | | `-1llu
-    | | `-)
-    | `-;
-    |-ExpressionStatement
-    | |-UnknownExpression
     | | |-UnknownExpression
     | | | |-IdExpression
     | | | | `-UnqualifiedId
     | | | |   `-x
     | | | |-.
     | | | `-~
     | | |-decltype
     | | |-(
     | | |-x
     | | |-)
     | | |-(
     | | `-)
     | `-;
     `-}
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UnqualifiedIdTemplateId) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+      R"cpp(
+template<typename T>
+T f();
+void test() {
+  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"));
+}
+
 TEST_P(SyntaxTreeTest, QualifiedId) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 namespace n {
   struct S {
`-CompoundStatement
     | | |   `-f
     | | |-(
     | | `-)
     | `-;
     |-ExpressionStatement
     | |-UnknownExpression
     | | |-IdExpression
     | | | |-NestedNameSpecifier
     | | | | |-IdentifierNameSpecifier
     | | | | | `-n
     | | | | |-::
     | | | | |-IdentifierNameSpecifier
     | | | | | `-S
     | | | | |-::
     | | | | |-SimpleTemplateNameSpecifier
     | | | | | |-ST
     | | | | | |-<
`-CompoundStatement
     | | | |-NestedNameSpecifier
     | | | | |-SimpleTemplateNameSpecifier
     | | | | | |-ST
     | | | | | |-<
     | | | | | |-int
     | | | | | `->
     | | | | |-::
     | | | | |-IdentifierNameSpecifier
     | | | | | `-S
     | | | | `-::
     | | | |-template
     | | | `-UnqualifiedId
     | | |   |-f
     | | |   |-<
     | | |   |-int
     | | |   `->
     | | |-(
`-CompoundStatement
       | | |   `->
       | | |-(
       | | `-)
       | `-;
       `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, QualifiedIdDecltype) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct S {
   static void f(){}
 };

 | |   `-)
 | `-;
 |-SimpleDeclaration
 | |-unsigned
 | |-SimpleDeclarator
 | | |-operator
 | | |-""
 | | |-_r
 | | `-ParametersAndQualifiers
 | |   |-(
 | |   |-SimpleDeclaration
 | |   | |-const
 | |   | |-char
 | |   | `-SimpleDeclarator
 | |   |   `-*
 | |   `-)
 | `-;
 |-TemplateDeclaration
 | |-template
`-CompoundStatement
     | | |-xor_eq
     | | `-IntegerLiteralExpression
     | |   `-3
     | `-;
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, NestedBinaryOperator) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test(int a, int b) {
   (1 + 2) * (4 / 2);
   a + b + 42;
   a = b = 42;
   a + b * 4 + 2;
   a % 2 + b * 42;
`-CompoundStatement
     | |   | `-IntegerLiteralExpression
     | |   |   `-2
     | |   `-)
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-BinaryOperatorExpression
     | | | |-IdExpression
     | | | | `-UnqualifiedId
     | | | |   `-a
     | | | |-+
     | | | `-IdExpression
     | | |   `-UnqualifiedId
     | | |     `-b
     | | |-+
     | | `-IntegerLiteralExpression
     | |   `-42
`-CompoundStatement
     | | |   `-IntegerLiteralExpression
     | | |     `-4
     | | |-+
     | | `-IntegerLiteralExpression
     | |   `-2
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-BinaryOperatorExpression
     | | | |-IdExpression
     | | | | `-UnqualifiedId
     | | | |   `-a
     | | | |-%
     | | | `-IntegerLiteralExpression
     | | |   `-2
     | | |-+
     | | `-BinaryOperatorExpression
     | |   |-IdExpression
     | |   | `-UnqualifiedId
     | |   |   `-b
     | |   |-*
     | |   `-IntegerLiteralExpression
     | |     `-42
     | `-;
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, UserDefinedBinaryOperator) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {
   X& operator=(const X&);
   friend X operator+(X, const X&);

 | | | `-ParametersAndQualifiers
 | | |   |-(
 | | |   |-SimpleDeclaration
 | | |   | |-X
 | | |   | `-SimpleDeclarator
 | | |   |   `-&
 | | |   `-)
 | | `-;
 | |-SimpleDeclaration
 | | |-X
 | | |-SimpleDeclarator
 | | | |-operator
 | | | |-->*
 | | | `-ParametersAndQualifiers
 | | |   |-(
 | | |   |-SimpleDeclaration
 | | |   | `-int
`-SimpleDeclaration
   |   | `-SimpleDeclarator
   |   |   `-y
   |   |-,
   |   |-SimpleDeclaration
   |   | |-X
   |   | `-SimpleDeclarator
   |   |   |-*
   |   |   `-xp
   |   |-,
   |   |-SimpleDeclaration
   |   | |-int
   |   | `-SimpleDeclarator
   |   |   |-MemberPointer
   |   |   | |-X
   |   |   | |-::
   |   |   | `-*
   |   |   `-pmi
`-CompoundStatement
     | | `-IdExpression
     | |   `-UnqualifiedId
     | |     `-pmi
     | `-;
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, UserDefinedUnaryPrefixOperator) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {
   X operator++();
   bool operator!();

 | | `-;
 | |-}
 | `-;
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-X
   |   | `-SimpleDeclarator
   |   |   `-x
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
`-CompoundStatement
     | | `-IdExpression
     | |   `-UnqualifiedId
     | |     `-x
     | `-;
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, UserDefinedUnaryPostfixOperator) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {
   X operator++(int);
 };