blob: aa8844771d373a42a57aa2224da9dc7a92892bbf [file] [log] [blame]
//===- BuildTree.cpp ------------------------------------------*- C++ -*-=====//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "clang/Tooling/Syntax/BuildTree.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/AST/Stmt.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TokenKinds.h"
#include "clang/Lex/Lexer.h"
#include "clang/Tooling/Syntax/Nodes.h"
#include "clang/Tooling/Syntax/Tokens.h"
#include "clang/Tooling/Syntax/Tree.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
#include <map>
using namespace clang;
LLVM_ATTRIBUTE_UNUSED
static bool isImplicitExpr(clang::Expr *E) { return E->IgnoreImplicit() != E; }
/// A helper class for constructing the syntax tree while traversing a clang
/// AST.
///
/// At each point of the traversal we maintain a list of pending nodes.
/// Initially all tokens are added as pending nodes. When processing a clang AST
/// node, the clients need to:
/// - create a corresponding syntax node,
/// - assign roles to all pending child nodes with 'markChild' and
/// 'markChildToken',
/// - replace the child nodes with the new syntax node in the pending list
/// with 'foldNode'.
///
/// Note that all children are expected to be processed when building a node.
///
/// Call finalize() to finish building the tree and consume the root node.
class syntax::TreeBuilder {
public:
TreeBuilder(syntax::Arena &Arena) : Arena(Arena), Pending(Arena) {
for (const auto &T : Arena.tokenBuffer().expandedTokens())
LocationToToken.insert({T.location().getRawEncoding(), &T});
}
llvm::BumpPtrAllocator &allocator() { return Arena.allocator(); }
/// Populate children for \p New node, assuming it covers tokens from \p
/// Range.
void foldNode(llvm::ArrayRef<syntax::Token> Range, syntax::Tree *New);
/// Must be called with the range of each `DeclaratorDecl`. Ensures the
/// corresponding declarator nodes are covered by `SimpleDeclaration`.
void noticeDeclaratorRange(llvm::ArrayRef<syntax::Token> Range);
/// Notifies that we should not consume trailing semicolon when computing
/// token range of \p D.
void noticeDeclaratorWithoutSemicolon(Decl *D);
/// Mark the \p Child node with a corresponding \p Role. All marked children
/// should be consumed by foldNode.
/// (!) when called on expressions (clang::Expr is derived from clang::Stmt),
/// wraps expressions into expression statement.
void markStmtChild(Stmt *Child, NodeRole Role);
/// Should be called for expressions in non-statement position to avoid
/// wrapping into expression statement.
void markExprChild(Expr *Child, NodeRole Role);
/// Set role for a token starting at \p Loc.
void markChildToken(SourceLocation Loc, NodeRole R);
/// Finish building the tree and consume the root node.
syntax::TranslationUnit *finalize() && {
auto Tokens = Arena.tokenBuffer().expandedTokens();
assert(!Tokens.empty());
assert(Tokens.back().kind() == tok::eof);
// Build the root of the tree, consuming all the children.
Pending.foldChildren(Arena, Tokens.drop_back(),
new (Arena.allocator()) syntax::TranslationUnit);
auto *TU = cast<syntax::TranslationUnit>(std::move(Pending).finalize());
TU->assertInvariantsRecursive();
return TU;
}
/// getRange() finds the syntax tokens corresponding to the passed source
/// locations.
/// \p First is the start position of the first token and \p Last is the start
/// position of the last token.
llvm::ArrayRef<syntax::Token> getRange(SourceLocation First,
SourceLocation Last) const {
assert(First.isValid());
assert(Last.isValid());
assert(First == Last ||
Arena.sourceManager().isBeforeInTranslationUnit(First, Last));
return llvm::makeArrayRef(findToken(First), std::next(findToken(Last)));
}
llvm::ArrayRef<syntax::Token> getRange(const Decl *D) const {
auto Tokens = getRange(D->getBeginLoc(), D->getEndLoc());
if (llvm::isa<NamespaceDecl>(D))
return Tokens;
if (DeclsWithoutSemicolons.count(D))
return Tokens;
// FIXME: do not consume trailing semicolon on function definitions.
// Most declarations own a semicolon in syntax trees, but not in clang AST.
return withTrailingSemicolon(Tokens);
}
llvm::ArrayRef<syntax::Token> getExprRange(const Expr *E) const {
return getRange(E->getBeginLoc(), E->getEndLoc());
}
/// Find the adjusted range for the statement, consuming the trailing
/// semicolon when needed.
llvm::ArrayRef<syntax::Token> getStmtRange(const Stmt *S) const {
auto Tokens = getRange(S->getBeginLoc(), S->getEndLoc());
if (isa<CompoundStmt>(S))
return Tokens;
// Some statements miss a trailing semicolon, e.g. 'return', 'continue' and
// all statements that end with those. Consume this semicolon here.
if (Tokens.back().kind() == tok::semi)
return Tokens;
return withTrailingSemicolon(Tokens);
}
private:
llvm::ArrayRef<syntax::Token>
withTrailingSemicolon(llvm::ArrayRef<syntax::Token> Tokens) const {
assert(!Tokens.empty());
assert(Tokens.back().kind() != tok::eof);
// (!) we never consume 'eof', so looking at the next token is ok.
if (Tokens.back().kind() != tok::semi && Tokens.end()->kind() == tok::semi)
return llvm::makeArrayRef(Tokens.begin(), Tokens.end() + 1);
return Tokens;
}
/// Finds a token starting at \p L. The token must exist.
const syntax::Token *findToken(SourceLocation L) const;
/// A collection of trees covering the input tokens.
/// When created, each tree corresponds to a single token in the file.
/// Clients call 'foldChildren' to attach one or more subtrees to a parent
/// node and update the list of trees accordingly.
///
/// Ensures that added nodes properly nest and cover the whole token stream.
struct Forest {
Forest(syntax::Arena &A) {
assert(!A.tokenBuffer().expandedTokens().empty());
assert(A.tokenBuffer().expandedTokens().back().kind() == tok::eof);
// Create all leaf nodes.
// Note that we do not have 'eof' in the tree.
for (auto &T : A.tokenBuffer().expandedTokens().drop_back()) {
auto *L = new (A.allocator()) syntax::Leaf(&T);
L->Original = true;
L->CanModify = A.tokenBuffer().spelledForExpanded(T).hasValue();
Trees.insert(Trees.end(), {&T, NodeAndRole{L}});
}
}
~Forest() { assert(DelayedFolds.empty()); }
void assignRole(llvm::ArrayRef<syntax::Token> Range,
syntax::NodeRole Role) {
assert(!Range.empty());
auto It = Trees.lower_bound(Range.begin());
assert(It != Trees.end() && "no node found");
assert(It->first == Range.begin() && "no child with the specified range");
assert((std::next(It) == Trees.end() ||
std::next(It)->first == Range.end()) &&
"no child with the specified range");
It->second.Role = Role;
}
/// Add \p Node to the forest and attach child nodes based on \p Tokens.
void foldChildren(const syntax::Arena &A,
llvm::ArrayRef<syntax::Token> Tokens,
syntax::Tree *Node) {
// Execute delayed folds inside `Tokens`.
auto BeginExecuted = DelayedFolds.lower_bound(Tokens.begin());
auto It = BeginExecuted;
for (; It != DelayedFolds.end() && It->second.End <= Tokens.end(); ++It)
foldChildrenEager(A, llvm::makeArrayRef(It->first, It->second.End),
It->second.Node);
DelayedFolds.erase(BeginExecuted, It);
// Attach children to `Node`.
foldChildrenEager(A, Tokens, Node);
}
/// Schedule a call to `foldChildren` that will only be executed when
/// containing node is folded. The range of delayed nodes can be extended by
/// calling `extendDelayedFold`. Only one delayed node for each starting
/// token is allowed.
void foldChildrenDelayed(llvm::ArrayRef<syntax::Token> Tokens,
syntax::Tree *Node) {
assert(!Tokens.empty());
bool Inserted =
DelayedFolds.insert({Tokens.begin(), DelayedFold{Tokens.end(), Node}})
.second;
(void)Inserted;
assert(Inserted && "Multiple delayed folds start at the same token");
}
/// If there a delayed fold, starting at `ExtendedRange.begin()`, extends
/// its endpoint to `ExtendedRange.end()` and returns true.
/// Otherwise, returns false.
bool extendDelayedFold(llvm::ArrayRef<syntax::Token> ExtendedRange) {
assert(!ExtendedRange.empty());
auto It = DelayedFolds.find(ExtendedRange.data());
if (It == DelayedFolds.end())
return false;
assert(It->second.End <= ExtendedRange.end());
It->second.End = ExtendedRange.end();
return true;
}
// EXPECTS: all tokens were consumed and are owned by a single root node.
syntax::Node *finalize() && {
assert(Trees.size() == 1);
auto *Root = Trees.begin()->second.Node;
Trees = {};
return Root;
}
std::string str(const syntax::Arena &A) const {
std::string R;
for (auto It = Trees.begin(); It != Trees.end(); ++It) {
unsigned CoveredTokens =
It != Trees.end()
? (std::next(It)->first - It->first)
: A.tokenBuffer().expandedTokens().end() - It->first;
R += llvm::formatv("- '{0}' covers '{1}'+{2} tokens\n",
It->second.Node->kind(),
It->first->text(A.sourceManager()), CoveredTokens);
R += It->second.Node->dump(A);
}
return R;
}
private:
/// Implementation detail of `foldChildren`, does acutal folding ignoring
/// delayed folds.
void foldChildrenEager(const syntax::Arena &A,
llvm::ArrayRef<syntax::Token> Tokens,
syntax::Tree *Node) {
assert(Node->firstChild() == nullptr && "node already has children");
auto *FirstToken = Tokens.begin();
auto BeginChildren = Trees.lower_bound(FirstToken);
assert((BeginChildren == Trees.end() ||
BeginChildren->first == FirstToken) &&
"fold crosses boundaries of existing subtrees");
auto EndChildren = Trees.lower_bound(Tokens.end());
assert(
(EndChildren == Trees.end() || EndChildren->first == Tokens.end()) &&
"fold crosses boundaries of existing subtrees");
// (!) we need to go in reverse order, because we can only prepend.
for (auto It = EndChildren; It != BeginChildren; --It)
Node->prependChildLowLevel(std::prev(It)->second.Node,
std::prev(It)->second.Role);
// Mark that this node came from the AST and is backed by the source code.
Node->Original = true;
Node->CanModify = A.tokenBuffer().spelledForExpanded(Tokens).hasValue();
Trees.erase(BeginChildren, EndChildren);
Trees.insert({FirstToken, NodeAndRole(Node)});
}
/// A with a role that should be assigned to it when adding to a parent.
struct NodeAndRole {
explicit NodeAndRole(syntax::Node *Node)
: Node(Node), Role(NodeRole::Unknown) {}
syntax::Node *Node;
NodeRole Role;
};
/// Maps from the start token to a subtree starting at that token.
/// Keys in the map are pointers into the array of expanded tokens, so
/// pointer order corresponds to the order of preprocessor tokens.
/// FIXME: storing the end tokens is redundant.
/// FIXME: the key of a map is redundant, it is also stored in NodeForRange.
std::map<const syntax::Token *, NodeAndRole> Trees;
/// See documentation of `foldChildrenDelayed` for details.
struct DelayedFold {
const syntax::Token *End = nullptr;
syntax::Tree *Node = nullptr;
};
std::map<const syntax::Token *, DelayedFold> DelayedFolds;
};
/// For debugging purposes.
std::string str() { return Pending.str(Arena); }
syntax::Arena &Arena;
/// To quickly find tokens by their start location.
llvm::DenseMap</*SourceLocation*/ unsigned, const syntax::Token *>
LocationToToken;
Forest Pending;
llvm::DenseSet<Decl *> DeclsWithoutSemicolons;
};
namespace {
class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
public:
explicit BuildTreeVisitor(ASTContext &Ctx, syntax::TreeBuilder &Builder)
: Builder(Builder), LangOpts(Ctx.getLangOpts()) {}
bool shouldTraversePostOrder() const { return true; }
bool WalkUpFromDeclaratorDecl(DeclaratorDecl *D) {
// Ensure declarators are covered by SimpleDeclaration.
Builder.noticeDeclaratorRange(Builder.getRange(D));
// FIXME: build nodes for the declarator too.
return true;
}
bool WalkUpFromTypedefNameDecl(TypedefNameDecl *D) {
// Also a declarator.
Builder.noticeDeclaratorRange(Builder.getRange(D));
// FIXME: build nodes for the declarator too.
return true;
}
bool VisitDecl(Decl *D) {
assert(!D->isImplicit());
Builder.foldNode(Builder.getRange(D),
new (allocator()) syntax::UnknownDeclaration());
return true;
}
bool WalkUpFromTagDecl(TagDecl *C) {
// FIXME: build the ClassSpecifier node.
if (C->isFreeStanding()) {
// Class is a declaration specifier and needs a spanning declaration node.
Builder.foldNode(Builder.getRange(C),
new (allocator()) syntax::SimpleDeclaration);
return true;
}
return true;
}
bool WalkUpFromTranslationUnitDecl(TranslationUnitDecl *TU) {
// (!) we do not want to call VisitDecl(), the declaration for translation
// unit is built by finalize().
return true;
}
bool WalkUpFromCompoundStmt(CompoundStmt *S) {
using NodeRole = syntax::NodeRole;
Builder.markChildToken(S->getLBracLoc(), NodeRole::OpenParen);
for (auto *Child : S->body())
Builder.markStmtChild(Child, NodeRole::CompoundStatement_statement);
Builder.markChildToken(S->getRBracLoc(), NodeRole::CloseParen);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::CompoundStatement);
return true;
}
// Some statements are not yet handled by syntax trees.
bool WalkUpFromStmt(Stmt *S) {
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::UnknownStatement);
return true;
}
bool TraverseCXXForRangeStmt(CXXForRangeStmt *S) {
// We override to traverse range initializer as VarDecl.
// RAV traverses it as a statement, we produce invalid node kinds in that
// case.
// FIXME: should do this in RAV instead?
if (S->getInit() && !TraverseStmt(S->getInit()))
return false;
if (S->getLoopVariable() && !TraverseDecl(S->getLoopVariable()))
return false;
if (S->getRangeInit() && !TraverseStmt(S->getRangeInit()))
return false;
if (S->getBody() && !TraverseStmt(S->getBody()))
return false;
return true;
}
bool TraverseStmt(Stmt *S) {
if (auto *DS = llvm::dyn_cast_or_null<DeclStmt>(S)) {
// We want to consume the semicolon, make sure SimpleDeclaration does not.
for (auto *D : DS->decls())
Builder.noticeDeclaratorWithoutSemicolon(D);
} else if (auto *E = llvm::dyn_cast_or_null<Expr>(S)) {
// (!) do not recurse into subexpressions.
// we do not have syntax trees for expressions yet, so we only want to see
// the first top-level expression.
return WalkUpFromExpr(E->IgnoreImplicit());
}
return RecursiveASTVisitor::TraverseStmt(S);
}
// 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);
return true;
}
bool WalkUpFromNamespaceDecl(NamespaceDecl *S) {
auto Tokens = Builder.getRange(S);
if (Tokens.front().kind() == tok::coloncolon) {
// Handle nested namespace definitions. Those start at '::' token, e.g.
// namespace a^::b {}
// FIXME: build corresponding nodes for the name of this namespace.
return true;
}
Builder.foldNode(Tokens, new (allocator()) syntax::NamespaceDefinition);
return true;
}
// The code below is very regular, it could even be generated with some
// preprocessor magic. We merely assign roles to the corresponding children
// and fold resulting nodes.
bool WalkUpFromDeclStmt(DeclStmt *S) {
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::DeclarationStatement);
return true;
}
bool WalkUpFromNullStmt(NullStmt *S) {
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::EmptyStatement);
return true;
}
bool WalkUpFromSwitchStmt(SwitchStmt *S) {
Builder.markChildToken(S->getSwitchLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::SwitchStatement);
return true;
}
bool WalkUpFromCaseStmt(CaseStmt *S) {
Builder.markChildToken(S->getKeywordLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.markExprChild(S->getLHS(), syntax::NodeRole::CaseStatement_value);
Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::CaseStatement);
return true;
}
bool WalkUpFromDefaultStmt(DefaultStmt *S) {
Builder.markChildToken(S->getKeywordLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::DefaultStatement);
return true;
}
bool WalkUpFromIfStmt(IfStmt *S) {
Builder.markChildToken(S->getIfLoc(), syntax::NodeRole::IntroducerKeyword);
Builder.markStmtChild(S->getThen(),
syntax::NodeRole::IfStatement_thenStatement);
Builder.markChildToken(S->getElseLoc(),
syntax::NodeRole::IfStatement_elseKeyword);
Builder.markStmtChild(S->getElse(),
syntax::NodeRole::IfStatement_elseStatement);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::IfStatement);
return true;
}
bool WalkUpFromForStmt(ForStmt *S) {
Builder.markChildToken(S->getForLoc(), syntax::NodeRole::IntroducerKeyword);
Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::ForStatement);
return true;
}
bool WalkUpFromWhileStmt(WhileStmt *S) {
Builder.markChildToken(S->getWhileLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::WhileStatement);
return true;
}
bool WalkUpFromContinueStmt(ContinueStmt *S) {
Builder.markChildToken(S->getContinueLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::ContinueStatement);
return true;
}
bool WalkUpFromBreakStmt(BreakStmt *S) {
Builder.markChildToken(S->getBreakLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::BreakStatement);
return true;
}
bool WalkUpFromReturnStmt(ReturnStmt *S) {
Builder.markChildToken(S->getReturnLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.markExprChild(S->getRetValue(),
syntax::NodeRole::ReturnStatement_value);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::ReturnStatement);
return true;
}
bool WalkUpFromCXXForRangeStmt(CXXForRangeStmt *S) {
Builder.markChildToken(S->getForLoc(), syntax::NodeRole::IntroducerKeyword);
Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::RangeBasedForStatement);
return true;
}
bool WalkUpFromEmptyDecl(EmptyDecl *S) {
Builder.foldNode(Builder.getRange(S),
new (allocator()) syntax::EmptyDeclaration);
return true;
}
bool WalkUpFromStaticAssertDecl(StaticAssertDecl *S) {
Builder.markExprChild(S->getAssertExpr(),
syntax::NodeRole::StaticAssertDeclaration_condition);
Builder.markExprChild(S->getMessage(),
syntax::NodeRole::StaticAssertDeclaration_message);
Builder.foldNode(Builder.getRange(S),
new (allocator()) syntax::StaticAssertDeclaration);
return true;
}
bool WalkUpFromLinkageSpecDecl(LinkageSpecDecl *S) {
Builder.foldNode(Builder.getRange(S),
new (allocator()) syntax::LinkageSpecificationDeclaration);
return true;
}
bool WalkUpFromNamespaceAliasDecl(NamespaceAliasDecl *S) {
Builder.foldNode(Builder.getRange(S),
new (allocator()) syntax::NamespaceAliasDefinition);
return true;
}
bool WalkUpFromUsingDirectiveDecl(UsingDirectiveDecl *S) {
Builder.foldNode(Builder.getRange(S),
new (allocator()) syntax::UsingNamespaceDirective);
return true;
}
bool WalkUpFromUsingDecl(UsingDecl *S) {
Builder.foldNode(Builder.getRange(S),
new (allocator()) syntax::UsingDeclaration);
return true;
}
bool WalkUpFromUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *S) {
Builder.foldNode(Builder.getRange(S),
new (allocator()) syntax::UsingDeclaration);
return true;
}
bool WalkUpFromUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *S) {
Builder.foldNode(Builder.getRange(S),
new (allocator()) syntax::UsingDeclaration);
return true;
}
bool WalkUpFromTypeAliasDecl(TypeAliasDecl *S) {
Builder.foldNode(Builder.getRange(S),
new (allocator()) syntax::TypeAliasDeclaration);
return true;
}
private:
/// A small helper to save some typing.
llvm::BumpPtrAllocator &allocator() { return Builder.allocator(); }
syntax::TreeBuilder &Builder;
const LangOptions &LangOpts;
};
} // namespace
void syntax::TreeBuilder::foldNode(llvm::ArrayRef<syntax::Token> Range,
syntax::Tree *New) {
Pending.foldChildren(Arena, Range, New);
}
void syntax::TreeBuilder::noticeDeclaratorRange(
llvm::ArrayRef<syntax::Token> Range) {
if (Pending.extendDelayedFold(Range))
return;
Pending.foldChildrenDelayed(Range,
new (allocator()) syntax::SimpleDeclaration);
}
void syntax::TreeBuilder::noticeDeclaratorWithoutSemicolon(Decl *D) {
DeclsWithoutSemicolons.insert(D);
}
void syntax::TreeBuilder::markChildToken(SourceLocation Loc, NodeRole Role) {
if (Loc.isInvalid())
return;
Pending.assignRole(*findToken(Loc), Role);
}
void syntax::TreeBuilder::markStmtChild(Stmt *Child, NodeRole Role) {
if (!Child)
return;
auto Range = getStmtRange(Child);
// This is an expression in a statement position, consume the trailing
// semicolon and form an 'ExpressionStatement' node.
if (auto *E = dyn_cast<Expr>(Child)) {
Pending.assignRole(getExprRange(E),
NodeRole::ExpressionStatement_expression);
// (!) 'getRange(Stmt)' ensures this already covers a trailing semicolon.
Pending.foldChildren(Arena, Range,
new (allocator()) syntax::ExpressionStatement);
}
Pending.assignRole(Range, Role);
}
void syntax::TreeBuilder::markExprChild(Expr *Child, NodeRole Role) {
if (!Child)
return;
Pending.assignRole(getExprRange(Child), Role);
}
const syntax::Token *syntax::TreeBuilder::findToken(SourceLocation L) const {
auto It = LocationToToken.find(L.getRawEncoding());
assert(It != LocationToToken.end());
return It->second;
}
syntax::TranslationUnit *
syntax::buildSyntaxTree(Arena &A, const TranslationUnitDecl &TU) {
TreeBuilder Builder(A);
BuildTreeVisitor(TU.getASTContext(), Builder).TraverseAST(TU.getASTContext());
return std::move(Builder).finalize();
}