[SyntaxTree][Synthesis] Add support for Tree.

[eduucaldas]

Summary

In a future patch

• Implement helper function to generate Trees for tests
• Test Tree methods, namely findFirstLeaf and findLastLeaf

Builds upon https://reviews.llvm.org/D87495

[eduucaldas]

Rebase

[gribozavr2]

clang/include/clang/Tooling/Syntax/BuildTree.h

39

[eduucaldas]

Add argument names to function declaration

clang/include/clang/Tooling/Syntax/BuildTree.h

 /// `TokenKind`.
 syntax::Leaf *createLeaf(syntax::Arena &A, tok::TokenKind K,
                          StringRef Spelling);
 
 /// Infer the token spelling from its `TokenKind`, then create `Leaf` from
 /// this token
 syntax::Leaf *createLeaf(syntax::Arena &A, tok::TokenKind K);
 
+// Synthesis of Trees
+syntax::Tree *
+createTree(Arena &A,
+           std::vector<std::pair<syntax::Node *, syntax::NodeRole>> Children,
+           syntax::NodeKind K);
+
 // Synthesis of Syntax Nodes
 clang::syntax::EmptyStatement *createEmptyStatement(clang::syntax::Arena &A);
 
 } // namespace syntax
 } // namespace clang
 #endif

clang/lib/Tooling/Syntax/Synthesis.cpp

syntax::Leaf *clang::syntax::createLeaf(syntax::Arena &A, tok::TokenKind K) {
   const auto *Spelling = tok::getPunctuatorSpelling(K);
   if (!Spelling)
     Spelling = tok::getKeywordSpelling(K);
   assert(Spelling &&
          "Cannot infer the spelling of the token from its token kind.");
   return createLeaf(A, K, Spelling);
 }
 
+syntax::Tree *clang::syntax::createTree(
+    syntax::Arena &A,
+    std::vector<std::pair<syntax::Node *, syntax::NodeRole>> Children,
+    syntax::NodeKind K) {
+  auto *T = new (A.getAllocator()) syntax::Tree(K);
+  FactoryImpl::setCanModify(T);
+  for (auto ChildIt = Children.rbegin(); ChildIt != Children.rend();
+       std::advance(ChildIt, 1))
+    FactoryImpl::prependChildLowLevel(T, ChildIt->first, ChildIt->second);
+
+  T->assertInvariants();
+  return T;
+}
+
 syntax::EmptyStatement *clang::syntax::createEmptyStatement(syntax::Arena &A) {
   auto *S = new (A.getAllocator()) syntax::EmptyStatement;
   FactoryImpl::setCanModify(S);
   FactoryImpl::prependChildLowLevel(S, createLeaf(A, tok::semi),
                                     NodeRole::Unknown);
   S->assertInvariants();
   return S;
 }

clang/unittests/Tooling/Syntax/SynthesisTest.cpp

 //===- SynthesisTest.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests synthesis API for syntax trees.
 //
 //===----------------------------------------------------------------------===//
 
 #include "TreeTestBase.h"
 #include "clang/Tooling/Syntax/BuildTree.h"
+#include "clang/Tooling/Syntax/Nodes.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace clang::syntax;
 
 namespace {
 
 class SynthesisTest : public SyntaxTreeTest {
TEST_P(SynthesisTest, Leaf_Number) {
 
   auto *Leaf = createLeaf(*Arena, tok::numeric_constant, "1");
 
   EXPECT_TRUE(treeDumpEqual(Leaf, R"txt(
 '1' Detached synthesized
   )txt"));
 }
 
+TEST_P(SynthesisTest, Tree_Empty) {
+  buildTree("", GetParam());
+
+  auto *Tree = createTree(*Arena, {}, NodeKind::UnknownExpression);
+
+  EXPECT_TRUE(treeDumpEqual(Tree, R"txt(
+UnknownExpression Detached synthesized
+  )txt"));
+}
+
+TEST_P(SynthesisTest, Tree_Flat) {
+  buildTree("", GetParam());
+
+  auto *LeafLParen = createLeaf(*Arena, tok::l_paren);
+  auto *LeafRParen = createLeaf(*Arena, tok::r_paren);
+  auto *TreeParen = createTree(*Arena,
+                               {{LeafLParen, NodeRole::LeftHandSide},
+                                {LeafRParen, NodeRole::RightHandSide}},
+                               NodeKind::ParenExpression);
+
+  EXPECT_TRUE(treeDumpEqual(TreeParen, R"txt(
+ParenExpression Detached synthesized
+|-'(' LeftHandSide synthesized
+`-')' RightHandSide synthesized
+  )txt"));
+}
+
+TEST_P(SynthesisTest, Tree_OfTree) {
+  buildTree("", GetParam());
+
+  auto *Leaf1 = createLeaf(*Arena, tok::numeric_constant, "1");
+  auto *Int1 = createTree(*Arena, {{Leaf1, NodeRole::LiteralToken}},
+                          NodeKind::IntegerLiteralExpression);
+
+  auto *LeafPlus = createLeaf(*Arena, tok::plus);
+
+  auto *Leaf2 = createLeaf(*Arena, tok::numeric_constant, "2");
+  auto *Int2 = createTree(*Arena, {{Leaf2, NodeRole::LiteralToken}},
+                          NodeKind::IntegerLiteralExpression);
+
+  auto *TreeBinaryOperator = createTree(*Arena,
+                                        {{Int1, NodeRole::LeftHandSide},
+                                         {LeafPlus, NodeRole::OperatorToken},
+                                         {Int2, NodeRole::RightHandSide}},
+                                        NodeKind::BinaryOperatorExpression);
+
+  EXPECT_TRUE(treeDumpEqual(TreeBinaryOperator, R"txt(
+BinaryOperatorExpression Detached synthesized
+|-IntegerLiteralExpression LeftHandSide synthesized
+| `-'1' LiteralToken synthesized
+|-'+' OperatorToken synthesized
+`-IntegerLiteralExpression RightHandSide synthesized
+  `-'2' LiteralToken synthesized
+  )txt"));
+}
+
 TEST_P(SynthesisTest, Statement_EmptyStatement) {
   buildTree("", GetParam());
 
   auto *S = createEmptyStatement(*Arena);
   EXPECT_TRUE(treeDumpEqual(S, R"txt(
 EmptyStatement Detached synthesized
 `-';' synthesized
   )txt"));
 }
 } // namespace