Add support for DeclRefExpr in SyntaxTree, by generating IdExpressions

[eduucaldas]

clang/unittests/Tooling/Syntax/TreeTest.cpp

829

Perhaps we shouldn't differ between specifiers as that is semantical information

[eduucaldas]

.

clang/unittests/Tooling/Syntax/TreeTest.cpp

829

Followed the grammar, but added specifier in the end as we also hold the :: and not only the names

[gribozavr2]

clang/unittests/Tooling/Syntax/TreeTest.cpp

815

This part does not seem to appear in the source.

[eduucaldas]

cleanup for upstreaming

[gribozavr2]

clang/include/clang/Tooling/Syntax/Nodes.h

190

Should there be getters for various parts of the specifier?

203

Could you add more details? Feel free to even quote the relevant grammar bits.

211

unqualified-id in the grammar can be more than one token.

212

Could you swap the order of getters to match the source order?

clang/lib/Tooling/Syntax/BuildTree.cpp

618

Do we need to mark the role if it is unknown?

clang/unittests/Tooling/Syntax/TreeTest.cpp

751

Could you add more tests even if they fail today due to missing implementation?

a::b::operator-(a::b::S())
a::b::S2<int>::f()

etc. Basically cover the whole grammar in tests, if possible.

[eduucaldas]

clang/lib/Tooling/Syntax/BuildTree.cpp

618

Thanks, that had slipped through, sorry for that

[eduucaldas]

This comment was removed by eduucaldas.

[eduucaldas]

Answering simple comments

[gribozavr2]

clang/include/clang/Tooling/Syntax/Nodes.h

208

Please add a TODO for the accessor for the 'template' keyword (and a test that has that keyword).

[eduucaldas]

• cleanup for upstreaming
• better coverage for unqualified-id
• Better coverage for qualified-id
• Finish implementing unqualified-id.

[eduucaldas]

clang/include/clang/Tooling/Syntax/Nodes.h

190

I think not.

208

I can implement accessor. But I couldn't write a test with this template keyword that uses DeclRefExpr. This is the test I came up with, note that both expressions are represented as DependentScopeDeclRefExpr

215

Just by looking at code it is impossible to know if the accessed thing is optional or not.
IdExpression ALWAYS has a UnqualifiedId
IdExpression MAY have a NestedNameSpecifier
This same issue repeats in other places

[eduucaldas]

Fix mistake on getting SourceRange for template-id

[gribozavr2]

clang/include/clang/Tooling/Syntax/Nodes.h

185

Could you provide examples or a grammar quote in the comment?

205

"the size in std::vector<int>::size"

212

Could you add TODOs about adding accessors?

clang/unittests/Tooling/Syntax/TreeTest.cpp

696

Could you split off the parts of this test that don't depend on C++11?

979

"WithTemplateKeyword"

1097

"QualifiedIdDecltype" for consistency with other tests.

1105

Indent -2?

1108

Could you indent the second line?

[eduucaldas]

Aswering comments

[eduucaldas]

clang/include/clang/Tooling/Syntax/Nodes.h

190

Pospone to interface discussion with Yitzhak

212

Pospone to interface discussion with Yitzhak

clang/lib/Tooling/Syntax/Nodes.cpp

174–192

I was thinking and our problem is bigger than not testing for NodeRoles, we don't test accessors at all!

178

This should be an assert for now, as if that is not true it would be a logic problem. Same reasoning applies to CompoundStatement

[gribozavr2]

clang/lib/Tooling/Syntax/Nodes.cpp

178

Yep, feel free to change it to an assert.

[eduucaldas]

change if -> asserts

[MaskRay]

@eduucaldas

Hi, you can drop Reviewers: Subscribers: Tags: and the text Summary: from the git commit with the following script:

arcfilter () {
        arc amend
        git log -1 --pretty=%B | awk '/Reviewers:|Subscribers:/{p=1} /Reviewed By:|Differential Revision:/{p=0} !p && !/^Summary:$/ {sub(/^Summary: /,"");print}' | git commit --amend --date=now -F -
}

Reviewed By: is considered important by some people. Please keep the tag. (I have updated my script to use --date=now (setting author date to committer date))

https://reviews.llvm.org/D80978 contains a git pre-push hook to automate this.

clang/include/clang/Tooling/Syntax/Nodes.h

enum class NodeKind : uint16_t {
 
   // Expressions.
   UnknownExpression,
   PrefixUnaryOperatorExpression,
   PostfixUnaryOperatorExpression,
   BinaryOperatorExpression,
   CxxNullPtrExpression,
   IntegerLiteralExpression,
+  IdExpression,
 
   // Statements.
   UnknownStatement,
   DeclarationStatement,
   EmptyStatement,
   SwitchStatement,
   CaseStatement,
   DefaultStatement,
enum class NodeKind : uint16_t {
 
   // Declarators.
   SimpleDeclarator,
   ParenDeclarator,
 
   ArraySubscript,
   TrailingReturnType,
   ParametersAndQualifiers,
-  MemberPointer
+  MemberPointer,
+  NestedNameSpecifier,
+  NameSpecifier
 };
 /// For debugging purposes.
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, NodeKind K);
 
 /// A relation between a parent and child node, e.g. 'left-hand-side of
 /// a binary expression'. Used for implementing accessors.
 ///
 /// Some roles describe parent/child relations that occur multiple times in
enum class NodeRole : uint8_t {
   StaticAssertDeclaration_condition,
   StaticAssertDeclaration_message,
   SimpleDeclaration_declarator,
   TemplateDeclaration_declaration,
   ExplicitTemplateInstantiation_declaration,
   ArraySubscript_sizeExpression,
   TrailingReturnType_declarator,
   ParametersAndQualifiers_parameter,
-  ParametersAndQualifiers_trailingReturn
+  ParametersAndQualifiers_trailingReturn,
+  IdExpression_unqualifiedId,
+  IdExpression_qualifier
 };
 /// For debugging purposes.
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, NodeRole R);
 
 class SimpleDeclarator;
 
 /// A root node for a translation unit. Parent is always null.
 class TranslationUnit final : public Tree {

 public:
   Expression(NodeKind K) : Tree(K) {}
   static bool classof(const Node *N) {
     return NodeKind::UnknownExpression <= N->kind() &&
            N->kind() <= NodeKind::UnknownExpression;
   }
 };
 
+class NameSpecifier final : public Tree {
+public:
+  NameSpecifier() : Tree(NodeKind::NameSpecifier) {}
+  static bool classof(const Node *N) {
+    return N->kind() == NodeKind::NameSpecifier;
+  }
+};
+
+class NestedNameSpecifier final : public Tree {
+public:
+  NestedNameSpecifier() : Tree(NodeKind::NestedNameSpecifier) {}
+  static bool classof(const Node *N) {
+    return N->kind() <= NodeKind::NestedNameSpecifier;
+  }
+
+  std::vector<syntax::NameSpecifier *> specifiers();
+};
+
+/// An identifier expression, e.g. `n::S::a`. Modeled according to the grammar
+class IdExpression final : public Expression {
+public:
+  IdExpression() : Expression(NodeKind::IdExpression) {}
+  static bool classof(const Node *N) {
+    return N->kind() == NodeKind::IdExpression;
+  }
+
+  syntax::Leaf *unqualifiedId();
+  syntax::NestedNameSpecifier *qualifier();
+};
+
 /// An expression of an unknown kind, i.e. one not currently handled by the
 /// syntax tree.
 class UnknownExpression final : public Expression {
 public:
   UnknownExpression() : Expression(NodeKind::UnknownExpression) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::UnknownExpression;
   }
 };

clang/lib/Tooling/Syntax/BuildTree.cpp

public:
   // Some expressions are not yet handled by syntax trees.
   bool WalkUpFromExpr(Expr *E) {
     assert(!isImplicitExpr(E) && "should be handled by TraverseStmt");
     Builder.foldNode(Builder.getExprRange(E),
                      new (allocator()) syntax::UnknownExpression, E);
     return true;
   }
 
+  syntax::NestedNameSpecifier *
+  BuildNestedNameSpecifier(NestedNameSpecifierLoc QualifierLoc) {
+    if (!QualifierLoc)
+      return nullptr;
+    for (auto it = QualifierLoc; it; it = it.getPrefix()) {
+      auto *NS = new (allocator()) syntax::NameSpecifier;
+      Builder.foldNode(Builder.getRange(it.getLocalSourceRange()), NS, nullptr);
+      Builder.markChild(NS, syntax::NodeRole::Unknown);
+    }
+    auto *NNS = new (allocator()) syntax::NestedNameSpecifier;
+    Builder.foldNode(Builder.getRange(QualifierLoc.getSourceRange()), NNS,
+                     nullptr);
+    return NNS;
+  }
+
+  bool WalkUpFromDeclRefExpr(DeclRefExpr *S) {
+    if (auto *NNS = BuildNestedNameSpecifier(S->getQualifierLoc()))
+      Builder.markChild(NNS, syntax::NodeRole::IdExpression_qualifier);
+
+    Builder.markChildToken(S->getLocation(),
+                           syntax::NodeRole::IdExpression_unqualifiedId);
+    Builder.foldNode(Builder.getExprRange(S),
+                     new (allocator()) syntax::IdExpression, S);
+    return true;
+  }
+
   bool WalkUpFromIntegerLiteral(IntegerLiteral *S) {
     Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
     Builder.foldNode(Builder.getExprRange(S),
                      new (allocator()) syntax::IntegerLiteralExpression, S);
     return true;
   }
 
   bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {

clang/lib/Tooling/Syntax/Nodes.cpp

llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeKind K) {
   case NodeKind::IntegerLiteralExpression:
     return OS << "IntegerLiteralExpression";
   case NodeKind::PrefixUnaryOperatorExpression:
     return OS << "PrefixUnaryOperatorExpression";
   case NodeKind::PostfixUnaryOperatorExpression:
     return OS << "PostfixUnaryOperatorExpression";
   case NodeKind::BinaryOperatorExpression:
     return OS << "BinaryOperatorExpression";
+  case NodeKind::IdExpression:
+    return OS << "IdExpression";
   case NodeKind::UnknownStatement:
     return OS << "UnknownStatement";
   case NodeKind::DeclarationStatement:
     return OS << "DeclarationStatement";
   case NodeKind::EmptyStatement:
     return OS << "EmptyStatement";
   case NodeKind::SwitchStatement:
     return OS << "SwitchStatement";
llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeKind K) {
   case NodeKind::ArraySubscript:
     return OS << "ArraySubscript";
   case NodeKind::TrailingReturnType:
     return OS << "TrailingReturnType";
   case NodeKind::ParametersAndQualifiers:
     return OS << "ParametersAndQualifiers";
   case NodeKind::MemberPointer:
     return OS << "MemberPointer";
+  case NodeKind::NameSpecifier:
+    return OS << "NameSpecifier";
+  case NodeKind::NestedNameSpecifier:
+    return OS << "NestedNameSpecifier";
   }
   llvm_unreachable("unknown node kind");
 }
 
 llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeRole R) {
   switch (R) {
   case syntax::NodeRole::Detached:
     return OS << "Detached";
llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeRole R) {
   case syntax::NodeRole::ArraySubscript_sizeExpression:
     return OS << "ArraySubscript_sizeExpression";
   case syntax::NodeRole::TrailingReturnType_declarator:
     return OS << "TrailingReturnType_declarator";
   case syntax::NodeRole::ParametersAndQualifiers_parameter:
     return OS << "ParametersAndQualifiers_parameter";
   case syntax::NodeRole::ParametersAndQualifiers_trailingReturn:
     return OS << "ParametersAndQualifiers_trailingReturn";
+  case syntax::NodeRole::IdExpression_unqualifiedId:
+    return OS << "IdExpression_unqualifiedId";
+  case syntax::NodeRole::IdExpression_qualifier:
+    return OS << "IdExpression_qualifier";
   }
   llvm_unreachable("invalid role");
 }
 
+std::vector<syntax::NameSpecifier *> syntax::NestedNameSpecifier::specifiers() {
+  std::vector<syntax::NameSpecifier *> Children;
+  for (auto *C = firstChild(); C; C = C->nextSibling()) {
+    Children.push_back(llvm::cast<syntax::NameSpecifier>(C));
+  }
+  return Children;
+}
+
+syntax::NestedNameSpecifier *syntax::IdExpression::qualifier() {
+  return llvm::cast_or_null<syntax::NestedNameSpecifier>(
+      findChild(syntax::NodeRole::IdExpression_qualifier));
+}
+
+syntax::Leaf *syntax::IdExpression::unqualifiedId() {
+  return llvm::cast_or_null<syntax::Leaf>(
+      findChild(syntax::NodeRole::IdExpression_unqualifiedId));
+}
+
 syntax::Leaf *syntax::IntegerLiteralExpression::literalToken() {
   return llvm::cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::LiteralToken));
 }
 
 syntax::Leaf *syntax::CxxNullPtrExpression::nullPtrKeyword() {
   return llvm::cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::LiteralToken));

clang/unittests/Tooling/Syntax/TreeTest.cpp

`-CompoundStatement
     |-RangeBasedForStatement
     | |-for
     | |-(
     | |-SimpleDeclaration
     | | |-int
     | | |-SimpleDeclarator
     | | | `-x
     | | `-:
-    | |-UnknownExpression
+    | |-IdExpression
     | | `-a
     | |-)
     | `-EmptyStatement
     |   `-;
     `-}
 )txt"));
 }
 
`-SimpleDeclaration
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-UnknownExpression
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-test
     | | |-(
     | | `-)
     | `-;
     |-IfStatement
     | |-if
     | |-(
     | |-IntegerLiteralExpression
     | | `-1
     | |-)
     | |-ExpressionStatement
     | | |-UnknownExpression
-    | | | |-UnknownExpression
+    | | | |-IdExpression
     | | | | `-test
     | | | |-(
     | | | `-)
     | | `-;
     | |-else
     | `-ExpressionStatement
     |   |-UnknownExpression
-    |   | |-UnknownExpression
+    |   | |-IdExpression
     |   | | `-test
     |   | |-(
     |   | `-)
     |   `-;
     `-}
 )txt"));
 }
 
+TEST_P(SyntaxTreeTest, UnqualifiedId) {
+  EXPECT_TRUE(treeDumpEqual(
+      R"cpp(
+void test(int b) {
+  int a;
+  a = b;
+}
+)cpp",
+      R"txt(
+*: TranslationUnit
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+    |-{
+    |-DeclarationStatement
+    | |-SimpleDeclaration
+    | | |-int
+    | | `-SimpleDeclarator
+    | |   `-a
+    | `-;
+    |-ExpressionStatement
+    | |-BinaryOperatorExpression
+    | | |-IdExpression
+    | | | `-a
+    | | |-=
+    | | `-IdExpression
+    | |   `-b
+    | `-;
+    `-}
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest, QualifiedId) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+      R"cpp(
+namespace a {
+  namespace b {
+    struct S {
+      int i;
+      static void f(){}
+    };
+  }
+}
+void test(int b) {
+  ::a::b::S::f();
+}
+)cpp",
+      R"txt(
+*: TranslationUnit
+|-NamespaceDefinition
+| |-namespace
+| |-a
+| |-{
+| |-NamespaceDefinition
+| | |-namespace
+| | |-b
+| | |-{
+| | |-SimpleDeclaration
+| | | |-struct
+| | | |-S
+| | | |-{
+| | | |-SimpleDeclaration
+| | | | |-int
+| | | | |-SimpleDeclarator
+| | | | | `-i
+| | | | `-;
+| | | |-SimpleDeclaration
+| | | | |-static
+| | | | |-void
+| | | | |-SimpleDeclarator
+| | | | | |-f
+| | | | | `-ParametersAndQualifiers
+| | | | |   |-(
+| | | | |   `-)
+| | | | `-CompoundStatement
+| | | |   |-{
+| | | |   `-}
+| | | |-}
+| | | `-;
+| | `-}
+| `-}
+`-SimpleDeclaration
+  |-void
+  |-SimpleDeclarator
+  | |-test
+  | `-ParametersAndQualifiers
+  |   |-(
+  |   |-SimpleDeclaration
+  |   | |-int
+  |   | `-SimpleDeclarator
+  |   |   `-b
+  |   `-)
+  `-CompoundStatement
+    |-{
+    |-ExpressionStatement
+    | |-UnknownExpression
+    | | |-IdExpression
+    | | | |-NestedNameSpecifier
+    | | | | |-NameSpecifier
+    | | | | | `-::
+    | | | | |-NameSpecifier
+    | | | | | |-a
+    | | | | | `-::
+    | | | | |-NameSpecifier
+    | | | | | |-b
+    | | | | | `-::
+    | | | | `-NameSpecifier
+    | | | |   |-S
+    | | | |   `-::
+    | | | `-f
+    | | |-(
+    | | `-)
+    | `-;
+    `-}
+)txt"));
+}
+
 TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test() {
   nullptr;
 }
 )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
TEST_P(SyntaxTreeTest, IntegerLiteralWithDigitSeparators) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test() {
   1'2'0ull;
 }
 )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
`-SimpleDeclaration
   |   | |-int
   |   | `-SimpleDeclarator
   |   |   `-a
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-PostfixUnaryOperatorExpression
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-a
     | | `-++
     | `-;
     |-ExpressionStatement
     | |-PostfixUnaryOperatorExpression
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-a
     | | `---
     | `-;
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, PrefixUnaryOperator) {
`-SimpleDeclaration
   |   |   |-*
   |   |   `-ap
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |---
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-a
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-++
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-a
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-~
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-a
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |--
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-a
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-+
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-a
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-&
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-a
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-*
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-ap
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-!
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-a
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-__real
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-a
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-__imag
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-a
     | `-;
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, PrefixUnaryOperatorCxx) {
   if (!GetParam().isCXX()) {
`-SimpleDeclaration
   |   | `-SimpleDeclarator
   |   |   `-b
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-compl
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-a
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-not
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-b
     | `-;
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, BinaryOperator) {
   EXPECT_TRUE(treeDumpEqual(
`-CompoundStatement
     | | |-IntegerLiteralExpression
     | | | `-1
     | | |-==
     | | `-IntegerLiteralExpression
     | |   `-2
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-a
     | | |-=
     | | `-IntegerLiteralExpression
     | |   `-1
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-a
     | | |-<<=
     | | `-IntegerLiteralExpression
     | |   `-1
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-IntegerLiteralExpression
     | | | `-1
     | | |-||
     | | `-IntegerLiteralExpression
     | |   `-0
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-IntegerLiteralExpression
     | | | `-1
     | | |-&
     | | `-IntegerLiteralExpression
     | |   `-2
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-a
     | | |-^=
     | | `-IntegerLiteralExpression
     | |   `-3
     | `-;
     `-}
 )txt"));
 }
`-CompoundStatement
     | | |-IntegerLiteralExpression
     | | | `-1
     | | |-bitand
     | | `-IntegerLiteralExpression
     | |   `-2
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-a
     | | |-xor_eq
     | | `-IntegerLiteralExpression
     | |   `-3
     | `-;
     `-}
 )txt"));
 }
`-CompoundStatement
     | |   | |-/
     | |   | `-IntegerLiteralExpression
     | |   |   `-2
     | |   `-)
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-BinaryOperatorExpression
-    | | | |-UnknownExpression
+    | | | |-IdExpression
     | | | | `-a
     | | | |-+
-    | | | `-UnknownExpression
+    | | | `-IdExpression
     | | |   `-b
     | | |-+
     | | `-IntegerLiteralExpression
     | |   `-42
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-a
     | | |-=
     | | `-BinaryOperatorExpression
-    | |   |-UnknownExpression
+    | |   |-IdExpression
     | |   | `-b
     | |   |-=
     | |   `-IntegerLiteralExpression
     | |     `-42
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-BinaryOperatorExpression
-    | | | |-UnknownExpression
+    | | | |-IdExpression
     | | | | `-a
     | | | |-+
     | | | `-BinaryOperatorExpression
-    | | |   |-UnknownExpression
+    | | |   |-IdExpression
     | | |   | `-b
     | | |   |-*
     | | |   `-IntegerLiteralExpression
     | | |     `-4
     | | |-+
     | | `-IntegerLiteralExpression
     | |   `-2
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-BinaryOperatorExpression
-    | | | |-UnknownExpression
+    | | | |-IdExpression
     | | | | `-a
     | | | |-%
     | | | `-IntegerLiteralExpression
     | | |   `-2
     | | |-+
     | | `-BinaryOperatorExpression
-    | |   |-UnknownExpression
+    | |   |-IdExpression
     | |   | `-b
     | |   |-*
     | |   `-IntegerLiteralExpression
     | |     `-42
     | `-;
     `-}
 )txt"));
 }
`-SimpleDeclaration
   |   | |-X
   |   | `-SimpleDeclarator
   |   |   `-y
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-BinaryOperatorExpression
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-x
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-=
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-y
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
     | | |-UnknownExpression
-    | | | `-UnknownExpression
+    | | | `-IdExpression
     | | |   `-x
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-+
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-y
     | `-;
     |-ExpressionStatement
     | |-BinaryOperatorExpression
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-x
-    | | |-UnknownExpression
+    | | |-IdExpression
     | | | `-<
-    | | `-UnknownExpression
+    | | `-IdExpression
     | |   `-y
     | `-;
     `-}
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
   EXPECT_TRUE(treeDumpEqual(