maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Tooling/Syntax/BuildTree.cpp

1753 lines
65 KiB
C++
Raw Blame History

//===- 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/ASTFwd.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclarationName.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/IgnoreExpr.h"
#include "clang/AST/OperationKinds.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/AST/Stmt.h"
#include "clang/AST/TypeLoc.h"
#include "clang/AST/TypeLocVisitor.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/Specifiers.h"
#include "clang/Basic/TokenKinds.h"
#include "clang/Lex/Lexer.h"
#include "clang/Lex/LiteralSupport.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/DenseMap.h"
#include "llvm/ADT/PointerUnion.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/ScopeExit.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 <cstddef>
#include <map>
using namespace clang;
// Ignores the implicit `CXXConstructExpr` for copy/move constructor calls
// generated by the compiler, as well as in implicit conversions like the one
// wrapping `1` in `X x = 1;`.
static Expr *IgnoreImplicitConstructorSingleStep(Expr *E) {
if (auto *C = dyn_cast<CXXConstructExpr>(E)) {
auto NumArgs = C->getNumArgs();
if (NumArgs == 1 || (NumArgs > 1 && isa<CXXDefaultArgExpr>(C->getArg(1)))) {
Expr *A = C->getArg(0);
if (C->getParenOrBraceRange().isInvalid())
return A;
}
}
return E;
}
// In:
// struct X {
// X(int)
// };
// X x = X(1);
// Ignores the implicit `CXXFunctionalCastExpr` that wraps
// `CXXConstructExpr X(1)`.
static Expr *IgnoreCXXFunctionalCastExprWrappingConstructor(Expr *E) {
if (auto *F = dyn_cast<CXXFunctionalCastExpr>(E)) {
if (F->getCastKind() == CK_ConstructorConversion)
return F->getSubExpr();
}
return E;
}
static Expr *IgnoreImplicit(Expr *E) {
return IgnoreExprNodes(E, IgnoreImplicitSingleStep,
IgnoreImplicitConstructorSingleStep,
IgnoreCXXFunctionalCastExprWrappingConstructor);
}
LLVM_ATTRIBUTE_UNUSED
static bool isImplicitExpr(Expr *E) { return IgnoreImplicit(E) != E; }
namespace {
/// Get start location of the Declarator from the TypeLoc.
/// E.g.:
/// loc of `(` in `int (a)`
/// loc of `*` in `int *(a)`
/// loc of the first `(` in `int (*a)(int)`
/// loc of the `*` in `int *(a)(int)`
/// loc of the first `*` in `const int *const *volatile a;`
///
/// It is non-trivial to get the start location because TypeLocs are stored
/// inside out. In the example above `*volatile` is the TypeLoc returned
/// by `Decl.getTypeSourceInfo()`, and `*const` is what `.getPointeeLoc()`
/// returns.
struct GetStartLoc : TypeLocVisitor<GetStartLoc, SourceLocation> {
SourceLocation VisitParenTypeLoc(ParenTypeLoc T) {
auto L = Visit(T.getInnerLoc());
if (L.isValid())
return L;
return T.getLParenLoc();
}
// Types spelled in the prefix part of the declarator.
SourceLocation VisitPointerTypeLoc(PointerTypeLoc T) {
return HandlePointer(T);
}
SourceLocation VisitMemberPointerTypeLoc(MemberPointerTypeLoc T) {
return HandlePointer(T);
}
SourceLocation VisitBlockPointerTypeLoc(BlockPointerTypeLoc T) {
return HandlePointer(T);
}
SourceLocation VisitReferenceTypeLoc(ReferenceTypeLoc T) {
return HandlePointer(T);
}
SourceLocation VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc T) {
return HandlePointer(T);
}
// All other cases are not important, as they are either part of declaration
// specifiers (e.g. inheritors of TypeSpecTypeLoc) or introduce modifiers on
// existing declarators (e.g. QualifiedTypeLoc). They cannot start the
// declarator themselves, but their underlying type can.
SourceLocation VisitTypeLoc(TypeLoc T) {
auto N = T.getNextTypeLoc();
if (!N)
return SourceLocation();
return Visit(N);
}
SourceLocation VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc T) {
if (T.getTypePtr()->hasTrailingReturn())
return SourceLocation(); // avoid recursing into the suffix of declarator.
return VisitTypeLoc(T);
}
private:
template <class PtrLoc> SourceLocation HandlePointer(PtrLoc T) {
auto L = Visit(T.getPointeeLoc());
if (L.isValid())
return L;
return T.getLocalSourceRange().getBegin();
}
};
} // namespace
static CallExpr::arg_range dropDefaultArgs(CallExpr::arg_range Args) {
auto FirstDefaultArg =
llvm::find_if(Args, [](auto It) { return isa<CXXDefaultArgExpr>(It); });
return llvm::make_range(Args.begin(), FirstDefaultArg);
}
static syntax::NodeKind getOperatorNodeKind(const CXXOperatorCallExpr &E) {
switch (E.getOperator()) {
// Comparison
case OO_EqualEqual:
case OO_ExclaimEqual:
case OO_Greater:
case OO_GreaterEqual:
case OO_Less:
case OO_LessEqual:
case OO_Spaceship:
// Assignment
case OO_Equal:
case OO_SlashEqual:
case OO_PercentEqual:
case OO_CaretEqual:
case OO_PipeEqual:
case OO_LessLessEqual:
case OO_GreaterGreaterEqual:
case OO_PlusEqual:
case OO_MinusEqual:
case OO_StarEqual:
case OO_AmpEqual:
// Binary computation
case OO_Slash:
case OO_Percent:
case OO_Caret:
case OO_Pipe:
case OO_LessLess:
case OO_GreaterGreater:
case OO_AmpAmp:
case OO_PipePipe:
case OO_ArrowStar:
case OO_Comma:
return syntax::NodeKind::BinaryOperatorExpression;
case OO_Tilde:
case OO_Exclaim:
return syntax::NodeKind::PrefixUnaryOperatorExpression;
// Prefix/Postfix increment/decrement
case OO_PlusPlus:
case OO_MinusMinus:
switch (E.getNumArgs()) {
case 1:
return syntax::NodeKind::PrefixUnaryOperatorExpression;
case 2:
return syntax::NodeKind::PostfixUnaryOperatorExpression;
default:
llvm_unreachable("Invalid number of arguments for operator");
}
// Operators that can be unary or binary
case OO_Plus:
case OO_Minus:
case OO_Star:
case OO_Amp:
switch (E.getNumArgs()) {
case 1:
return syntax::NodeKind::PrefixUnaryOperatorExpression;
case 2:
return syntax::NodeKind::BinaryOperatorExpression;
default:
llvm_unreachable("Invalid number of arguments for operator");
}
return syntax::NodeKind::BinaryOperatorExpression;
// Not yet supported by SyntaxTree
case OO_New:
case OO_Delete:
case OO_Array_New:
case OO_Array_Delete:
case OO_Coawait:
case OO_Subscript:
case OO_Arrow:
return syntax::NodeKind::UnknownExpression;
case OO_Call:
return syntax::NodeKind::CallExpression;
case OO_Conditional: // not overloadable
case NUM_OVERLOADED_OPERATORS:
case OO_None:
llvm_unreachable("Not an overloadable operator");
}
llvm_unreachable("Unknown OverloadedOperatorKind enum");
}
/// Get the start of the qualified name. In the examples below it gives the
/// location of the `^`:
/// `int ^a;`
/// `int *^a;`
/// `int ^a::S::f(){}`
static SourceLocation getQualifiedNameStart(NamedDecl *D) {
assert((isa<DeclaratorDecl, TypedefNameDecl>(D)) &&
"only DeclaratorDecl and TypedefNameDecl are supported.");
auto DN = D->getDeclName();
bool IsAnonymous = DN.isIdentifier() && !DN.getAsIdentifierInfo();
if (IsAnonymous)
return SourceLocation();
if (const auto *DD = dyn_cast<DeclaratorDecl>(D)) {
if (DD->getQualifierLoc()) {
return DD->getQualifierLoc().getBeginLoc();
}
}
return D->getLocation();
}
/// Gets the range of the initializer inside an init-declarator C++ [dcl.decl].
/// `int a;` -> range of ``,
/// `int *a = nullptr` -> range of `= nullptr`.
/// `int a{}` -> range of `{}`.
/// `int a()` -> range of `()`.
static SourceRange getInitializerRange(Decl *D) {
if (auto *V = dyn_cast<VarDecl>(D)) {
auto *I = V->getInit();
// Initializers in range-based-for are not part of the declarator
if (I && !V->isCXXForRangeDecl())
return I->getSourceRange();
}
return SourceRange();
}
/// Gets the range of declarator as defined by the C++ grammar. E.g.
/// `int a;` -> range of `a`,
/// `int *a;` -> range of `*a`,
/// `int a[10];` -> range of `a[10]`,
/// `int a[1][2][3];` -> range of `a[1][2][3]`,
/// `int *a = nullptr` -> range of `*a = nullptr`.
/// `int S::f(){}` -> range of `S::f()`.
/// FIXME: \p Name must be a source range.
static SourceRange getDeclaratorRange(const SourceManager &SM, TypeLoc T,
SourceLocation Name,
SourceRange Initializer) {
SourceLocation Start = GetStartLoc().Visit(T);
SourceLocation End = T.getEndLoc();
if (Name.isValid()) {
if (Start.isInvalid())
Start = Name;
// End of TypeLoc could be invalid if the type is invalid, fallback to the
// NameLoc.
if (End.isInvalid() || SM.isBeforeInTranslationUnit(End, Name))
End = Name;
}
if (Initializer.isValid()) {
auto InitializerEnd = Initializer.getEnd();
assert(SM.isBeforeInTranslationUnit(End, InitializerEnd) ||
End == InitializerEnd);
End = InitializerEnd;
}
return SourceRange(Start, End);
}
namespace {
/// All AST hierarchy roots that can be represented as pointers.
using ASTPtr = llvm::PointerUnion<Stmt *, Decl *>;
/// Maintains a mapping from AST to syntax tree nodes. This class will get more
/// complicated as we support more kinds of AST nodes, e.g. TypeLocs.
/// FIXME: expose this as public API.
class ASTToSyntaxMapping {
public:
void add(ASTPtr From, syntax::Tree *To) {
assert(To != nullptr);
assert(!From.isNull());
bool Added = Nodes.insert({From, To}).second;
(void)Added;
assert(Added && "mapping added twice");
}
void add(NestedNameSpecifierLoc From, syntax::Tree *To) {
assert(To != nullptr);
assert(From.hasQualifier());
bool Added = NNSNodes.insert({From, To}).second;
(void)Added;
assert(Added && "mapping added twice");
}
syntax::Tree *find(ASTPtr P) const { return Nodes.lookup(P); }
syntax::Tree *find(NestedNameSpecifierLoc P) const {
return NNSNodes.lookup(P);
}
private:
llvm::DenseMap<ASTPtr, syntax::Tree *> Nodes;
llvm::DenseMap<NestedNameSpecifierLoc, syntax::Tree *> NNSNodes;
};
} // namespace
/// 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.getTokenBuffer().expandedTokens())
LocationToToken.insert({T.location(), &T});
}
llvm::BumpPtrAllocator &allocator() { return Arena.getAllocator(); }
const SourceManager &sourceManager() const {
return Arena.getSourceManager();
}
/// Populate children for \p New node, assuming it covers tokens from \p
/// Range.
void foldNode(ArrayRef<syntax::Token> Range, syntax::Tree *New, ASTPtr From) {
assert(New);
Pending.foldChildren(Arena, Range, New);
if (From)
Mapping.add(From, New);
}
void foldNode(ArrayRef<syntax::Token> Range, syntax::Tree *New, TypeLoc L) {
// FIXME: add mapping for TypeLocs
foldNode(Range, New, nullptr);
}
void foldNode(llvm::ArrayRef<syntax::Token> Range, syntax::Tree *New,
NestedNameSpecifierLoc From) {
assert(New);
Pending.foldChildren(Arena, Range, New);
if (From)
Mapping.add(From, New);
}
/// Populate children for \p New list, assuming it covers tokens from a
/// subrange of \p SuperRange.
void foldList(ArrayRef<syntax::Token> SuperRange, syntax::List *New,
ASTPtr From) {
assert(New);
auto ListRange = Pending.shrinkToFitList(SuperRange);
Pending.foldChildren(Arena, ListRange, New);
if (From)
Mapping.add(From, New);
}
/// Notifies that we should not consume trailing semicolon when computing
/// token range of \p D.
void noticeDeclWithoutSemicolon(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);
/// Set role for \p T.
void markChildToken(const syntax::Token *T, NodeRole R);
/// Set role for \p N.
void markChild(syntax::Node *N, NodeRole R);
/// Set role for the syntax node matching \p N.
void markChild(ASTPtr N, NodeRole R);
/// Set role for the syntax node matching \p N.
void markChild(NestedNameSpecifierLoc N, NodeRole R);
/// Finish building the tree and consume the root node.
syntax::TranslationUnit *finalize() && {
auto Tokens = Arena.getTokenBuffer().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.getAllocator()) syntax::TranslationUnit);
auto *TU = cast<syntax::TranslationUnit>(std::move(Pending).finalize());
TU->assertInvariantsRecursive();
return TU;
}
/// Finds a token starting at \p L. The token must exist if \p L is valid.
const syntax::Token *findToken(SourceLocation L) const;
/// Finds the syntax tokens corresponding to the \p SourceRange.
ArrayRef<syntax::Token> getRange(SourceRange Range) const {
assert(Range.isValid());
return getRange(Range.getBegin(), Range.getEnd());
}
/// 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.
ArrayRef<syntax::Token> getRange(SourceLocation First,
SourceLocation Last) const {
assert(First.isValid());
assert(Last.isValid());
assert(First == Last ||
Arena.getSourceManager().isBeforeInTranslationUnit(First, Last));
return llvm::makeArrayRef(findToken(First), std::next(findToken(Last)));
}
ArrayRef<syntax::Token>
getTemplateRange(const ClassTemplateSpecializationDecl *D) const {
auto Tokens = getRange(D->getSourceRange());
return maybeAppendSemicolon(Tokens, D);
}
/// Returns true if \p D is the last declarator in a chain and is thus
/// reponsible for creating SimpleDeclaration for the whole chain.
bool isResponsibleForCreatingDeclaration(const Decl *D) const {
assert((isa<DeclaratorDecl, TypedefNameDecl>(D)) &&
"only DeclaratorDecl and TypedefNameDecl are supported.");
const Decl *Next = D->getNextDeclInContext();
// There's no next sibling, this one is responsible.
if (Next == nullptr) {
return true;
}
// Next sibling is not the same type, this one is responsible.
if (D->getKind() != Next->getKind()) {
return true;
}
// Next sibling doesn't begin at the same loc, it must be a different
// declaration, so this declarator is responsible.
if (Next->getBeginLoc() != D->getBeginLoc()) {
return true;
}
// NextT is a member of the same declaration, and we need the last member to
// create declaration. This one is not responsible.
return false;
}
ArrayRef<syntax::Token> getDeclarationRange(Decl *D) {
ArrayRef<syntax::Token> Tokens;
// We want to drop the template parameters for specializations.
if (const auto *S = dyn_cast<TagDecl>(D))
Tokens = getRange(S->TypeDecl::getBeginLoc(), S->getEndLoc());
else
Tokens = getRange(D->getSourceRange());
return maybeAppendSemicolon(Tokens, D);
}
ArrayRef<syntax::Token> getExprRange(const Expr *E) const {
return getRange(E->getSourceRange());
}
/// Find the adjusted range for the statement, consuming the trailing
/// semicolon when needed.
ArrayRef<syntax::Token> getStmtRange(const Stmt *S) const {
auto Tokens = getRange(S->getSourceRange());
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:
ArrayRef<syntax::Token> maybeAppendSemicolon(ArrayRef<syntax::Token> Tokens,
const Decl *D) const {
if (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);
}
ArrayRef<syntax::Token>
withTrailingSemicolon(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;
}
void setRole(syntax::Node *N, NodeRole R) {
assert(N->getRole() == NodeRole::Detached);
N->setRole(R);
}
/// 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.getTokenBuffer().expandedTokens().empty());
assert(A.getTokenBuffer().expandedTokens().back().kind() == tok::eof);
// Create all leaf nodes.
// Note that we do not have 'eof' in the tree.
for (const auto &T : A.getTokenBuffer().expandedTokens().drop_back()) {
auto *L = new (A.getAllocator()) syntax::Leaf(&T);
L->Original = true;
L->CanModify = A.getTokenBuffer().spelledForExpanded(T).hasValue();
Trees.insert(Trees.end(), {&T, L});
}
}
void assignRole(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");
assert(It->second->getRole() == NodeRole::Detached &&
"re-assigning role for a child");
It->second->setRole(Role);
}
/// Shrink \p Range to a subrange that only contains tokens of a list.
/// List elements and delimiters should already have correct roles.
ArrayRef<syntax::Token> shrinkToFitList(ArrayRef<syntax::Token> Range) {
auto BeginChildren = Trees.lower_bound(Range.begin());
assert((BeginChildren == Trees.end() ||
BeginChildren->first == Range.begin()) &&
"Range crosses boundaries of existing subtrees");
auto EndChildren = Trees.lower_bound(Range.end());
assert(
(EndChildren == Trees.end() || EndChildren->first == Range.end()) &&
"Range crosses boundaries of existing subtrees");
auto BelongsToList = [](decltype(Trees)::value_type KV) {
auto Role = KV.second->getRole();
return Role == syntax::NodeRole::ListElement ||
Role == syntax::NodeRole::ListDelimiter;
};
auto BeginListChildren =
std::find_if(BeginChildren, EndChildren, BelongsToList);
auto EndListChildren =
std::find_if_not(BeginListChildren, EndChildren, BelongsToList);
return ArrayRef<syntax::Token>(BeginListChildren->first,
EndListChildren->first);
}
/// Add \p Node to the forest and attach child nodes based on \p Tokens.
void foldChildren(const syntax::Arena &A, ArrayRef<syntax::Token> Tokens,
syntax::Tree *Node) {
// Attach children to `Node`.
assert(Node->getFirstChild() == 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");
for (auto It = BeginChildren; It != EndChildren; ++It) {
auto *C = It->second;
if (C->getRole() == NodeRole::Detached)
C->setRole(NodeRole::Unknown);
Node->appendChildLowLevel(C);
}
// Mark that this node came from the AST and is backed by the source code.
Node->Original = true;
Node->CanModify =
A.getTokenBuffer().spelledForExpanded(Tokens).hasValue();
Trees.erase(BeginChildren, EndChildren);
Trees.insert({FirstToken, Node});
}
// 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;
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.getTokenBuffer().expandedTokens().end() - It->first;
R += std::string(
formatv("- '{0}' covers '{1}'+{2} tokens\n", It->second->getKind(),
It->first->text(A.getSourceManager()), CoveredTokens));
R += It->second->dump(A.getSourceManager());
}
return R;
}
private:
/// 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.
std::map<const syntax::Token *, syntax::Node *> Trees;
};
/// For debugging purposes.
std::string str() { return Pending.str(Arena); }
syntax::Arena &Arena;
/// To quickly find tokens by their start location.
llvm::DenseMap<SourceLocation, const syntax::Token *> LocationToToken;
Forest Pending;
llvm::DenseSet<Decl *> DeclsWithoutSemicolons;
ASTToSyntaxMapping Mapping;
};
namespace {
class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
public:
explicit BuildTreeVisitor(ASTContext &Context, syntax::TreeBuilder &Builder)
: Builder(Builder), Context(Context) {}
bool shouldTraversePostOrder() const { return true; }
bool WalkUpFromDeclaratorDecl(DeclaratorDecl *DD) {
return processDeclaratorAndDeclaration(DD);
}
bool WalkUpFromTypedefNameDecl(TypedefNameDecl *TD) {
return processDeclaratorAndDeclaration(TD);
}
bool VisitDecl(Decl *D) {
assert(!D->isImplicit());
Builder.foldNode(Builder.getDeclarationRange(D),
new (allocator()) syntax::UnknownDeclaration(), D);
return true;
}
// RAV does not call WalkUpFrom* on explicit instantiations, so we have to
// override Traverse.
// FIXME: make RAV call WalkUpFrom* instead.
bool
TraverseClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *C) {
if (!RecursiveASTVisitor::TraverseClassTemplateSpecializationDecl(C))
return false;
if (C->isExplicitSpecialization())
return true; // we are only interested in explicit instantiations.
auto *Declaration =
cast<syntax::SimpleDeclaration>(handleFreeStandingTagDecl(C));
foldExplicitTemplateInstantiation(
Builder.getTemplateRange(C), Builder.findToken(C->getExternLoc()),
Builder.findToken(C->getTemplateKeywordLoc()), Declaration, C);
return true;
}
bool WalkUpFromTemplateDecl(TemplateDecl *S) {
foldTemplateDeclaration(
Builder.getDeclarationRange(S),
Builder.findToken(S->getTemplateParameters()->getTemplateLoc()),
Builder.getDeclarationRange(S->getTemplatedDecl()), S);
return true;
}
bool WalkUpFromTagDecl(TagDecl *C) {
// FIXME: build the ClassSpecifier node.
if (!C->isFreeStanding()) {
assert(C->getNumTemplateParameterLists() == 0);
return true;
}
handleFreeStandingTagDecl(C);
return true;
}
syntax::Declaration *handleFreeStandingTagDecl(TagDecl *C) {
assert(C->isFreeStanding());
// Class is a declaration specifier and needs a spanning declaration node.
auto DeclarationRange = Builder.getDeclarationRange(C);
syntax::Declaration *Result = new (allocator()) syntax::SimpleDeclaration;
Builder.foldNode(DeclarationRange, Result, nullptr);
// Build TemplateDeclaration nodes if we had template parameters.
auto ConsumeTemplateParameters = [&](const TemplateParameterList &L) {
const auto *TemplateKW = Builder.findToken(L.getTemplateLoc());
auto R = llvm::makeArrayRef(TemplateKW, DeclarationRange.end());
Result =
foldTemplateDeclaration(R, TemplateKW, DeclarationRange, nullptr);
DeclarationRange = R;
};
if (auto *S = dyn_cast<ClassTemplatePartialSpecializationDecl>(C))
ConsumeTemplateParameters(*S->getTemplateParameters());
for (unsigned I = C->getNumTemplateParameterLists(); 0 < I; --I)
ConsumeTemplateParameters(*C->getTemplateParameterList(I - 1));
return Result;
}
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::Statement);
Builder.markChildToken(S->getRBracLoc(), NodeRole::CloseParen);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::CompoundStatement, S);
return true;
}
// Some statements are not yet handled by syntax trees.
bool WalkUpFromStmt(Stmt *S) {
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::UnknownStatement, S);
return true;
}
bool TraverseIfStmt(IfStmt *S) {
bool Result = [&, this]() {
if (S->getInit() && !TraverseStmt(S->getInit())) {
return false;
}
// In cases where the condition is an initialized declaration in a
// statement, we want to preserve the declaration and ignore the
// implicit condition expression in the syntax tree.
if (S->hasVarStorage()) {
if (!TraverseStmt(S->getConditionVariableDeclStmt()))
return false;
} else if (S->getCond() && !TraverseStmt(S->getCond()))
return false;
if (S->getThen() && !TraverseStmt(S->getThen()))
return false;
if (S->getElse() && !TraverseStmt(S->getElse()))
return false;
return true;
}();
WalkUpFromIfStmt(S);
return Result;
}
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?
bool Result = [&, this]() {
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;
}();
WalkUpFromCXXForRangeStmt(S);
return Result;
}
bool TraverseStmt(Stmt *S) {
if (auto *DS = dyn_cast_or_null<DeclStmt>(S)) {
// We want to consume the semicolon, make sure SimpleDeclaration does not.
for (auto *D : DS->decls())
Builder.noticeDeclWithoutSemicolon(D);
} else if (auto *E = dyn_cast_or_null<Expr>(S)) {
return RecursiveASTVisitor::TraverseStmt(IgnoreImplicit(E));
}
return RecursiveASTVisitor::TraverseStmt(S);
}
bool TraverseOpaqueValueExpr(OpaqueValueExpr *VE) {
// OpaqueValue doesn't correspond to concrete syntax, ignore it.
return true;
}
// 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;
}
bool TraverseUserDefinedLiteral(UserDefinedLiteral *S) {
// The semantic AST node `UserDefinedLiteral` (UDL) may have one child node
// referencing the location of the UDL suffix (`_w` in `1.2_w`). The
// UDL suffix location does not point to the beginning of a token, so we
// can't represent the UDL suffix as a separate syntax tree node.
return WalkUpFromUserDefinedLiteral(S);
}
syntax::UserDefinedLiteralExpression *
buildUserDefinedLiteral(UserDefinedLiteral *S) {
switch (S->getLiteralOperatorKind()) {
case UserDefinedLiteral::LOK_Integer:
return new (allocator()) syntax::IntegerUserDefinedLiteralExpression;
case UserDefinedLiteral::LOK_Floating:
return new (allocator()) syntax::FloatUserDefinedLiteralExpression;
case UserDefinedLiteral::LOK_Character:
return new (allocator()) syntax::CharUserDefinedLiteralExpression;
case UserDefinedLiteral::LOK_String:
return new (allocator()) syntax::StringUserDefinedLiteralExpression;
case UserDefinedLiteral::LOK_Raw:
case UserDefinedLiteral::LOK_Template:
// For raw literal operator and numeric literal operator template we
// cannot get the type of the operand in the semantic AST. We get this
// information from the token. As integer and floating point have the same
// token kind, we run `NumericLiteralParser` again to distinguish them.
auto TokLoc = S->getBeginLoc();
auto TokSpelling =
Builder.findToken(TokLoc)->text(Context.getSourceManager());
auto Literal =
NumericLiteralParser(TokSpelling, TokLoc, Context.getSourceManager(),
Context.getLangOpts(), Context.getTargetInfo(),
Context.getDiagnostics());
if (Literal.isIntegerLiteral())
return new (allocator()) syntax::IntegerUserDefinedLiteralExpression;
else {
assert(Literal.isFloatingLiteral());
return new (allocator()) syntax::FloatUserDefinedLiteralExpression;
}
}
llvm_unreachable("Unknown literal operator kind.");
}
bool WalkUpFromUserDefinedLiteral(UserDefinedLiteral *S) {
Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);
Builder.foldNode(Builder.getExprRange(S), buildUserDefinedLiteral(S), S);
return true;
}
// FIXME: Fix `NestedNameSpecifierLoc::getLocalSourceRange` for the
// `DependentTemplateSpecializationType` case.
/// Given a nested-name-specifier return the range for the last name
/// specifier.
///
/// e.g. `std::T::template X<U>::` => `template X<U>::`
SourceRange getLocalSourceRange(const NestedNameSpecifierLoc &NNSLoc) {
auto SR = NNSLoc.getLocalSourceRange();
// The method `NestedNameSpecifierLoc::getLocalSourceRange` *should*
// return the desired `SourceRange`, but there is a corner case. For a
// `DependentTemplateSpecializationType` this method returns its
// qualifiers as well, in other words in the example above this method
// returns `T::template X<U>::` instead of only `template X<U>::`
if (auto TL = NNSLoc.getTypeLoc()) {
if (auto DependentTL =
TL.getAs<DependentTemplateSpecializationTypeLoc>()) {
// The 'template' keyword is always present in dependent template
// specializations. Except in the case of incorrect code
// TODO: Treat the case of incorrect code.
SR.setBegin(DependentTL.getTemplateKeywordLoc());
}
}
return SR;
}
syntax::NodeKind getNameSpecifierKind(const NestedNameSpecifier &NNS) {
switch (NNS.getKind()) {
case NestedNameSpecifier::Global:
return syntax::NodeKind::GlobalNameSpecifier;
case NestedNameSpecifier::Namespace:
case NestedNameSpecifier::NamespaceAlias:
case NestedNameSpecifier::Identifier:
return syntax::NodeKind::IdentifierNameSpecifier;
case NestedNameSpecifier::TypeSpecWithTemplate:
return syntax::NodeKind::SimpleTemplateNameSpecifier;
case NestedNameSpecifier::TypeSpec: {
const auto *NNSType = NNS.getAsType();
assert(NNSType);
if (isa<DecltypeType>(NNSType))
return syntax::NodeKind::DecltypeNameSpecifier;
if (isa<TemplateSpecializationType, DependentTemplateSpecializationType>(
NNSType))
return syntax::NodeKind::SimpleTemplateNameSpecifier;
return syntax::NodeKind::IdentifierNameSpecifier;
}
default:
// FIXME: Support Microsoft's __super
llvm::report_fatal_error("We don't yet support the __super specifier",
true);
}
}
syntax::NameSpecifier *
buildNameSpecifier(const NestedNameSpecifierLoc &NNSLoc) {
assert(NNSLoc.hasQualifier());
auto NameSpecifierTokens =
Builder.getRange(getLocalSourceRange(NNSLoc)).drop_back();
switch (getNameSpecifierKind(*NNSLoc.getNestedNameSpecifier())) {
case syntax::NodeKind::GlobalNameSpecifier:
return new (allocator()) syntax::GlobalNameSpecifier;
case syntax::NodeKind::IdentifierNameSpecifier: {
assert(NameSpecifierTokens.size() == 1);
Builder.markChildToken(NameSpecifierTokens.begin(),
syntax::NodeRole::Unknown);
auto *NS = new (allocator()) syntax::IdentifierNameSpecifier;
Builder.foldNode(NameSpecifierTokens, NS, nullptr);
return NS;
}
case syntax::NodeKind::SimpleTemplateNameSpecifier: {
// TODO: Build `SimpleTemplateNameSpecifier` children and implement
// accessors to them.
// Be aware, we cannot do that simply by calling `TraverseTypeLoc`,
// some `TypeLoc`s have inside them the previous name specifier and
// we want to treat them independently.
auto *NS = new (allocator()) syntax::SimpleTemplateNameSpecifier;
Builder.foldNode(NameSpecifierTokens, NS, nullptr);
return NS;
}
case syntax::NodeKind::DecltypeNameSpecifier: {
const auto TL = NNSLoc.getTypeLoc().castAs<DecltypeTypeLoc>();
if (!RecursiveASTVisitor::TraverseDecltypeTypeLoc(TL))
return nullptr;
auto *NS = new (allocator()) syntax::DecltypeNameSpecifier;
// TODO: Implement accessor to `DecltypeNameSpecifier` inner
// `DecltypeTypeLoc`.
// For that add mapping from `TypeLoc` to `syntax::Node*` then:
// Builder.markChild(TypeLoc, syntax::NodeRole);
Builder.foldNode(NameSpecifierTokens, NS, nullptr);
return NS;
}
default:
llvm_unreachable("getChildKind() does not return this value");
}
}
// To build syntax tree nodes for NestedNameSpecifierLoc we override
// Traverse instead of WalkUpFrom because we want to traverse the children
// ourselves and build a list instead of a nested tree of name specifier
// prefixes.
bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc QualifierLoc) {
if (!QualifierLoc)
return true;
for (auto It = QualifierLoc; It; It = It.getPrefix()) {
auto *NS = buildNameSpecifier(It);
if (!NS)
return false;
Builder.markChild(NS, syntax::NodeRole::ListElement);
Builder.markChildToken(It.getEndLoc(), syntax::NodeRole::ListDelimiter);
}
Builder.foldNode(Builder.getRange(QualifierLoc.getSourceRange()),
new (allocator()) syntax::NestedNameSpecifier,
QualifierLoc);
return true;
}
syntax::IdExpression *buildIdExpression(NestedNameSpecifierLoc QualifierLoc,
SourceLocation TemplateKeywordLoc,
SourceRange UnqualifiedIdLoc,
ASTPtr From) {
if (QualifierLoc) {
Builder.markChild(QualifierLoc, syntax::NodeRole::Qualifier);
if (TemplateKeywordLoc.isValid())
Builder.markChildToken(TemplateKeywordLoc,
syntax::NodeRole::TemplateKeyword);
}
auto *TheUnqualifiedId = new (allocator()) syntax::UnqualifiedId;
Builder.foldNode(Builder.getRange(UnqualifiedIdLoc), TheUnqualifiedId,
nullptr);
Builder.markChild(TheUnqualifiedId, syntax::NodeRole::UnqualifiedId);
auto IdExpressionBeginLoc =
QualifierLoc ? QualifierLoc.getBeginLoc() : UnqualifiedIdLoc.getBegin();
auto *TheIdExpression = new (allocator()) syntax::IdExpression;
Builder.foldNode(
Builder.getRange(IdExpressionBeginLoc, UnqualifiedIdLoc.getEnd()),
TheIdExpression, From);
return TheIdExpression;
}
bool WalkUpFromMemberExpr(MemberExpr *S) {
// For `MemberExpr` with implicit `this->` we generate a simple
// `id-expression` syntax node, beacuse an implicit `member-expression` is
// syntactically undistinguishable from an `id-expression`
if (S->isImplicitAccess()) {
buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),
SourceRange(S->getMemberLoc(), S->getEndLoc()), S);
return true;
}
auto *TheIdExpression = buildIdExpression(
S->getQualifierLoc(), S->getTemplateKeywordLoc(),
SourceRange(S->getMemberLoc(), S->getEndLoc()), nullptr);
Builder.markChild(TheIdExpression, syntax::NodeRole::Member);
Builder.markExprChild(S->getBase(), syntax::NodeRole::Object);
Builder.markChildToken(S->getOperatorLoc(), syntax::NodeRole::AccessToken);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::MemberExpression, S);
return true;
}
bool WalkUpFromDeclRefExpr(DeclRefExpr *S) {
buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),
SourceRange(S->getLocation(), S->getEndLoc()), S);
return true;
}
// Same logic as DeclRefExpr.
bool WalkUpFromDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *S) {
buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),
SourceRange(S->getLocation(), S->getEndLoc()), S);
return true;
}
bool WalkUpFromCXXThisExpr(CXXThisExpr *S) {
if (!S->isImplicit()) {
Builder.markChildToken(S->getLocation(),
syntax::NodeRole::IntroducerKeyword);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::ThisExpression, S);
}
return true;
}
bool WalkUpFromParenExpr(ParenExpr *S) {
Builder.markChildToken(S->getLParen(), syntax::NodeRole::OpenParen);
Builder.markExprChild(S->getSubExpr(), syntax::NodeRole::SubExpression);
Builder.markChildToken(S->getRParen(), syntax::NodeRole::CloseParen);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::ParenExpression, 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 WalkUpFromCharacterLiteral(CharacterLiteral *S) {
Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::CharacterLiteralExpression, S);
return true;
}
bool WalkUpFromFloatingLiteral(FloatingLiteral *S) {
Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::FloatingLiteralExpression, S);
return true;
}
bool WalkUpFromStringLiteral(StringLiteral *S) {
Builder.markChildToken(S->getBeginLoc(), syntax::NodeRole::LiteralToken);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::StringLiteralExpression, S);
return true;
}
bool WalkUpFromCXXBoolLiteralExpr(CXXBoolLiteralExpr *S) {
Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::BoolLiteralExpression, S);
return true;
}
bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) {
Builder.markChildToken(S->getLocation(), syntax::NodeRole::LiteralToken);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::CxxNullPtrExpression, S);
return true;
}
bool WalkUpFromUnaryOperator(UnaryOperator *S) {
Builder.markChildToken(S->getOperatorLoc(),
syntax::NodeRole::OperatorToken);
Builder.markExprChild(S->getSubExpr(), syntax::NodeRole::Operand);
if (S->isPostfix())
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::PostfixUnaryOperatorExpression,
S);
else
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::PrefixUnaryOperatorExpression,
S);
return true;
}
bool WalkUpFromBinaryOperator(BinaryOperator *S) {
Builder.markExprChild(S->getLHS(), syntax::NodeRole::LeftHandSide);
Builder.markChildToken(S->getOperatorLoc(),
syntax::NodeRole::OperatorToken);
Builder.markExprChild(S->getRHS(), syntax::NodeRole::RightHandSide);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::BinaryOperatorExpression, S);
return true;
}
/// Builds `CallArguments` syntax node from arguments that appear in source
/// code, i.e. not default arguments.
syntax::CallArguments *
buildCallArguments(CallExpr::arg_range ArgsAndDefaultArgs) {
auto Args = dropDefaultArgs(ArgsAndDefaultArgs);
for (auto *Arg : Args) {
Builder.markExprChild(Arg, syntax::NodeRole::ListElement);
const auto *DelimiterToken =
std::next(Builder.findToken(Arg->getEndLoc()));
if (DelimiterToken->kind() == clang::tok::TokenKind::comma)
Builder.markChildToken(DelimiterToken, syntax::NodeRole::ListDelimiter);
}
auto *Arguments = new (allocator()) syntax::CallArguments;
if (!Args.empty())
Builder.foldNode(Builder.getRange((*Args.begin())->getBeginLoc(),
(*(Args.end() - 1))->getEndLoc()),
Arguments, nullptr);
return Arguments;
}
bool WalkUpFromCallExpr(CallExpr *S) {
Builder.markExprChild(S->getCallee(), syntax::NodeRole::Callee);
const auto *LParenToken =
std::next(Builder.findToken(S->getCallee()->getEndLoc()));
// FIXME: Assert that `LParenToken` is indeed a `l_paren` once we have fixed
// the test on decltype desctructors.
if (LParenToken->kind() == clang::tok::l_paren)
Builder.markChildToken(LParenToken, syntax::NodeRole::OpenParen);
Builder.markChild(buildCallArguments(S->arguments()),
syntax::NodeRole::Arguments);
Builder.markChildToken(S->getRParenLoc(), syntax::NodeRole::CloseParen);
Builder.foldNode(Builder.getRange(S->getSourceRange()),
new (allocator()) syntax::CallExpression, S);
return true;
}
bool WalkUpFromCXXConstructExpr(CXXConstructExpr *S) {
// Ignore the implicit calls to default constructors.
if ((S->getNumArgs() == 0 || isa<CXXDefaultArgExpr>(S->getArg(0))) &&
S->getParenOrBraceRange().isInvalid())
return true;
return RecursiveASTVisitor::WalkUpFromCXXConstructExpr(S);
}
bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
// To construct a syntax tree of the same shape for calls to built-in and
// user-defined operators, ignore the `DeclRefExpr` that refers to the
// operator and treat it as a simple token. Do that by traversing
// arguments instead of children.
for (auto *child : S->arguments()) {
// A postfix unary operator is declared as taking two operands. The
// second operand is used to distinguish from its prefix counterpart. In
// the semantic AST this "phantom" operand is represented as a
// `IntegerLiteral` with invalid `SourceLocation`. We skip visiting this
// operand because it does not correspond to anything written in source
// code.
if (child->getSourceRange().isInvalid()) {
assert(getOperatorNodeKind(*S) ==
syntax::NodeKind::PostfixUnaryOperatorExpression);
continue;
}
if (!TraverseStmt(child))
return false;
}
return WalkUpFromCXXOperatorCallExpr(S);
}
bool WalkUpFromCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
switch (getOperatorNodeKind(*S)) {
case syntax::NodeKind::BinaryOperatorExpression:
Builder.markExprChild(S->getArg(0), syntax::NodeRole::LeftHandSide);
Builder.markChildToken(S->getOperatorLoc(),
syntax::NodeRole::OperatorToken);
Builder.markExprChild(S->getArg(1), syntax::NodeRole::RightHandSide);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::BinaryOperatorExpression, S);
return true;
case syntax::NodeKind::PrefixUnaryOperatorExpression:
Builder.markChildToken(S->getOperatorLoc(),
syntax::NodeRole::OperatorToken);
Builder.markExprChild(S->getArg(0), syntax::NodeRole::Operand);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::PrefixUnaryOperatorExpression,
S);
return true;
case syntax::NodeKind::PostfixUnaryOperatorExpression:
Builder.markChildToken(S->getOperatorLoc(),
syntax::NodeRole::OperatorToken);
Builder.markExprChild(S->getArg(0), syntax::NodeRole::Operand);
Builder.foldNode(Builder.getExprRange(S),
new (allocator()) syntax::PostfixUnaryOperatorExpression,
S);
return true;
case syntax::NodeKind::CallExpression: {
Builder.markExprChild(S->getArg(0), syntax::NodeRole::Callee);
const auto *LParenToken =
std::next(Builder.findToken(S->getArg(0)->getEndLoc()));
// FIXME: Assert that `LParenToken` is indeed a `l_paren` once we have
// fixed the test on decltype desctructors.
if (LParenToken->kind() == clang::tok::l_paren)
Builder.markChildToken(LParenToken, syntax::NodeRole::OpenParen);
Builder.markChild(buildCallArguments(CallExpr::arg_range(
S->arg_begin() + 1, S->arg_end())),
syntax::NodeRole::Arguments);
Builder.markChildToken(S->getRParenLoc(), syntax::NodeRole::CloseParen);
Builder.foldNode(Builder.getRange(S->getSourceRange()),
new (allocator()) syntax::CallExpression, S);
return true;
}
case syntax::NodeKind::UnknownExpression:
return WalkUpFromExpr(S);
default:
llvm_unreachable("getOperatorNodeKind() does not return this value");
}
}
bool WalkUpFromCXXDefaultArgExpr(CXXDefaultArgExpr *S) { return true; }
bool WalkUpFromNamespaceDecl(NamespaceDecl *S) {
auto Tokens = Builder.getDeclarationRange(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, S);
return true;
}
// FIXME: Deleting the `TraverseParenTypeLoc` override doesn't change test
// results. Find test coverage or remove it.
bool TraverseParenTypeLoc(ParenTypeLoc L) {
// We reverse order of traversal to get the proper syntax structure.
if (!WalkUpFromParenTypeLoc(L))
return false;
return TraverseTypeLoc(L.getInnerLoc());
}
bool WalkUpFromParenTypeLoc(ParenTypeLoc L) {
Builder.markChildToken(L.getLParenLoc(), syntax::NodeRole::OpenParen);
Builder.markChildToken(L.getRParenLoc(), syntax::NodeRole::CloseParen);
Builder.foldNode(Builder.getRange(L.getLParenLoc(), L.getRParenLoc()),
new (allocator()) syntax::ParenDeclarator, L);
return true;
}
// Declarator chunks, they are produced by type locs and some clang::Decls.
bool WalkUpFromArrayTypeLoc(ArrayTypeLoc L) {
Builder.markChildToken(L.getLBracketLoc(), syntax::NodeRole::OpenParen);
Builder.markExprChild(L.getSizeExpr(), syntax::NodeRole::Size);
Builder.markChildToken(L.getRBracketLoc(), syntax::NodeRole::CloseParen);
Builder.foldNode(Builder.getRange(L.getLBracketLoc(), L.getRBracketLoc()),
new (allocator()) syntax::ArraySubscript, L);
return true;
}
syntax::ParameterDeclarationList *
buildParameterDeclarationList(ArrayRef<ParmVarDecl *> Params) {
for (auto *P : Params) {
Builder.markChild(P, syntax::NodeRole::ListElement);
const auto *DelimiterToken = std::next(Builder.findToken(P->getEndLoc()));
if (DelimiterToken->kind() == clang::tok::TokenKind::comma)
Builder.markChildToken(DelimiterToken, syntax::NodeRole::ListDelimiter);
}
auto *Parameters = new (allocator()) syntax::ParameterDeclarationList;
if (!Params.empty())
Builder.foldNode(Builder.getRange(Params.front()->getBeginLoc(),
Params.back()->getEndLoc()),
Parameters, nullptr);
return Parameters;
}
bool WalkUpFromFunctionTypeLoc(FunctionTypeLoc L) {
Builder.markChildToken(L.getLParenLoc(), syntax::NodeRole::OpenParen);
Builder.markChild(buildParameterDeclarationList(L.getParams()),
syntax::NodeRole::Parameters);
Builder.markChildToken(L.getRParenLoc(), syntax::NodeRole::CloseParen);
Builder.foldNode(Builder.getRange(L.getLParenLoc(), L.getEndLoc()),
new (allocator()) syntax::ParametersAndQualifiers, L);
return true;
}
bool WalkUpFromFunctionProtoTypeLoc(FunctionProtoTypeLoc L) {
if (!L.getTypePtr()->hasTrailingReturn())
return WalkUpFromFunctionTypeLoc(L);
auto *TrailingReturnTokens = buildTrailingReturn(L);
// Finish building the node for parameters.
Builder.markChild(TrailingReturnTokens, syntax::NodeRole::TrailingReturn);
return WalkUpFromFunctionTypeLoc(L);
}
bool TraverseMemberPointerTypeLoc(MemberPointerTypeLoc L) {
// In the source code "void (Y::*mp)()" `MemberPointerTypeLoc` corresponds
// to "Y::*" but it points to a `ParenTypeLoc` that corresponds to
// "(Y::*mp)" We thus reverse the order of traversal to get the proper
// syntax structure.
if (!WalkUpFromMemberPointerTypeLoc(L))
return false;
return TraverseTypeLoc(L.getPointeeLoc());
}
bool WalkUpFromMemberPointerTypeLoc(MemberPointerTypeLoc L) {
auto SR = L.getLocalSourceRange();
Builder.foldNode(Builder.getRange(SR),
new (allocator()) syntax::MemberPointer, L);
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, S);
return true;
}
bool WalkUpFromNullStmt(NullStmt *S) {
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::EmptyStatement, S);
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, S);
return true;
}
bool WalkUpFromCaseStmt(CaseStmt *S) {
Builder.markChildToken(S->getKeywordLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.markExprChild(S->getLHS(), syntax::NodeRole::CaseValue);
Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::CaseStatement, S);
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, S);
return true;
}
bool WalkUpFromIfStmt(IfStmt *S) {
Builder.markChildToken(S->getIfLoc(), syntax::NodeRole::IntroducerKeyword);
Stmt *ConditionStatement = S->getCond();
if (S->hasVarStorage())
ConditionStatement = S->getConditionVariableDeclStmt();
Builder.markStmtChild(ConditionStatement, syntax::NodeRole::Condition);
Builder.markStmtChild(S->getThen(), syntax::NodeRole::ThenStatement);
Builder.markChildToken(S->getElseLoc(), syntax::NodeRole::ElseKeyword);
Builder.markStmtChild(S->getElse(), syntax::NodeRole::ElseStatement);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::IfStatement, S);
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, S);
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, S);
return true;
}
bool WalkUpFromContinueStmt(ContinueStmt *S) {
Builder.markChildToken(S->getContinueLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::ContinueStatement, S);
return true;
}
bool WalkUpFromBreakStmt(BreakStmt *S) {
Builder.markChildToken(S->getBreakLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::BreakStatement, S);
return true;
}
bool WalkUpFromReturnStmt(ReturnStmt *S) {
Builder.markChildToken(S->getReturnLoc(),
syntax::NodeRole::IntroducerKeyword);
Builder.markExprChild(S->getRetValue(), syntax::NodeRole::ReturnValue);
Builder.foldNode(Builder.getStmtRange(S),
new (allocator()) syntax::ReturnStatement, S);
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, S);
return true;
}
bool WalkUpFromEmptyDecl(EmptyDecl *S) {
Builder.foldNode(Builder.getDeclarationRange(S),
new (allocator()) syntax::EmptyDeclaration, S);
return true;
}
bool WalkUpFromStaticAssertDecl(StaticAssertDecl *S) {
Builder.markExprChild(S->getAssertExpr(), syntax::NodeRole::Condition);
Builder.markExprChild(S->getMessage(), syntax::NodeRole::Message);
Builder.foldNode(Builder.getDeclarationRange(S),
new (allocator()) syntax::StaticAssertDeclaration, S);
return true;
}
bool WalkUpFromLinkageSpecDecl(LinkageSpecDecl *S) {
Builder.foldNode(Builder.getDeclarationRange(S),
new (allocator()) syntax::LinkageSpecificationDeclaration,
S);
return true;
}
bool WalkUpFromNamespaceAliasDecl(NamespaceAliasDecl *S) {
Builder.foldNode(Builder.getDeclarationRange(S),
new (allocator()) syntax::NamespaceAliasDefinition, S);
return true;
}
bool WalkUpFromUsingDirectiveDecl(UsingDirectiveDecl *S) {
Builder.foldNode(Builder.getDeclarationRange(S),
new (allocator()) syntax::UsingNamespaceDirective, S);
return true;
}
bool WalkUpFromUsingDecl(UsingDecl *S) {
Builder.foldNode(Builder.getDeclarationRange(S),
new (allocator()) syntax::UsingDeclaration, S);
return true;
}
bool WalkUpFromUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *S) {
Builder.foldNode(Builder.getDeclarationRange(S),
new (allocator()) syntax::UsingDeclaration, S);
return true;
}
bool WalkUpFromUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *S) {
Builder.foldNode(Builder.getDeclarationRange(S),
new (allocator()) syntax::UsingDeclaration, S);
return true;
}
bool WalkUpFromTypeAliasDecl(TypeAliasDecl *S) {
Builder.foldNode(Builder.getDeclarationRange(S),
new (allocator()) syntax::TypeAliasDeclaration, S);
return true;
}
private:
/// Folds SimpleDeclarator node (if present) and in case this is the last
/// declarator in the chain it also folds SimpleDeclaration node.
template <class T> bool processDeclaratorAndDeclaration(T *D) {
auto Range = getDeclaratorRange(
Builder.sourceManager(), D->getTypeSourceInfo()->getTypeLoc(),
getQualifiedNameStart(D), getInitializerRange(D));
// There doesn't have to be a declarator (e.g. `void foo(int)` only has
// declaration, but no declarator).
if (!Range.getBegin().isValid()) {
Builder.markChild(new (allocator()) syntax::DeclaratorList,
syntax::NodeRole::Declarators);
Builder.foldNode(Builder.getDeclarationRange(D),
new (allocator()) syntax::SimpleDeclaration, D);
return true;
}
auto *N = new (allocator()) syntax::SimpleDeclarator;
Builder.foldNode(Builder.getRange(Range), N, nullptr);
Builder.markChild(N, syntax::NodeRole::ListElement);
if (!Builder.isResponsibleForCreatingDeclaration(D)) {
// If this is not the last declarator in the declaration we expect a
// delimiter after it.
const auto *DelimiterToken = std::next(Builder.findToken(Range.getEnd()));
if (DelimiterToken->kind() == clang::tok::TokenKind::comma)
Builder.markChildToken(DelimiterToken, syntax::NodeRole::ListDelimiter);
} else {
auto *DL = new (allocator()) syntax::DeclaratorList;
auto DeclarationRange = Builder.getDeclarationRange(D);
Builder.foldList(DeclarationRange, DL, nullptr);
Builder.markChild(DL, syntax::NodeRole::Declarators);
Builder.foldNode(DeclarationRange,
new (allocator()) syntax::SimpleDeclaration, D);
}
return true;
}
/// Returns the range of the built node.
syntax::TrailingReturnType *buildTrailingReturn(FunctionProtoTypeLoc L) {
assert(L.getTypePtr()->hasTrailingReturn());
auto ReturnedType = L.getReturnLoc();
// Build node for the declarator, if any.
auto ReturnDeclaratorRange = SourceRange(GetStartLoc().Visit(ReturnedType),
ReturnedType.getEndLoc());
syntax::SimpleDeclarator *ReturnDeclarator = nullptr;
if (ReturnDeclaratorRange.isValid()) {
ReturnDeclarator = new (allocator()) syntax::SimpleDeclarator;
Builder.foldNode(Builder.getRange(ReturnDeclaratorRange),
ReturnDeclarator, nullptr);
}
// Build node for trailing return type.
auto Return = Builder.getRange(ReturnedType.getSourceRange());
const auto *Arrow = Return.begin() - 1;
assert(Arrow->kind() == tok::arrow);
auto Tokens = llvm::makeArrayRef(Arrow, Return.end());
Builder.markChildToken(Arrow, syntax::NodeRole::ArrowToken);
if (ReturnDeclarator)
Builder.markChild(ReturnDeclarator, syntax::NodeRole::Declarator);
auto *R = new (allocator()) syntax::TrailingReturnType;
Builder.foldNode(Tokens, R, L);
return R;
}
void foldExplicitTemplateInstantiation(
ArrayRef<syntax::Token> Range, const syntax::Token *ExternKW,
const syntax::Token *TemplateKW,
syntax::SimpleDeclaration *InnerDeclaration, Decl *From) {
assert(!ExternKW || ExternKW->kind() == tok::kw_extern);
assert(TemplateKW && TemplateKW->kind() == tok::kw_template);
Builder.markChildToken(ExternKW, syntax::NodeRole::ExternKeyword);
Builder.markChildToken(TemplateKW, syntax::NodeRole::IntroducerKeyword);
Builder.markChild(InnerDeclaration, syntax::NodeRole::Declaration);
Builder.foldNode(
Range, new (allocator()) syntax::ExplicitTemplateInstantiation, From);
}
syntax::TemplateDeclaration *foldTemplateDeclaration(
ArrayRef<syntax::Token> Range, const syntax::Token *TemplateKW,
ArrayRef<syntax::Token> TemplatedDeclaration, Decl *From) {
assert(TemplateKW && TemplateKW->kind() == tok::kw_template);
Builder.markChildToken(TemplateKW, syntax::NodeRole::IntroducerKeyword);
auto *N = new (allocator()) syntax::TemplateDeclaration;
Builder.foldNode(Range, N, From);
Builder.markChild(N, syntax::NodeRole::Declaration);
return N;
}
/// A small helper to save some typing.
llvm::BumpPtrAllocator &allocator() { return Builder.allocator(); }
syntax::TreeBuilder &Builder;
const ASTContext &Context;
};
} // namespace
void syntax::TreeBuilder::noticeDeclWithoutSemicolon(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::markChildToken(const syntax::Token *T, NodeRole R) {
if (!T)
return;
Pending.assignRole(*T, R);
}
void syntax::TreeBuilder::markChild(syntax::Node *N, NodeRole R) {
assert(N);
setRole(N, R);
}
void syntax::TreeBuilder::markChild(ASTPtr N, NodeRole R) {
auto *SN = Mapping.find(N);
assert(SN != nullptr);
setRole(SN, R);
}
void syntax::TreeBuilder::markChild(NestedNameSpecifierLoc NNSLoc, NodeRole R) {
auto *SN = Mapping.find(NNSLoc);
assert(SN != nullptr);
setRole(SN, R);
}
void syntax::TreeBuilder::markStmtChild(Stmt *Child, NodeRole Role) {
if (!Child)
return;
syntax::Tree *ChildNode;
if (Expr *ChildExpr = dyn_cast<Expr>(Child)) {
// This is an expression in a statement position, consume the trailing
// semicolon and form an 'ExpressionStatement' node.
markExprChild(ChildExpr, NodeRole::Expression);
ChildNode = new (allocator()) syntax::ExpressionStatement;
// (!) 'getStmtRange()' ensures this covers a trailing semicolon.
Pending.foldChildren(Arena, getStmtRange(Child), ChildNode);
} else {
ChildNode = Mapping.find(Child);
}
assert(ChildNode != nullptr);
setRole(ChildNode, Role);
}
void syntax::TreeBuilder::markExprChild(Expr *Child, NodeRole Role) {
if (!Child)
return;
Child = IgnoreImplicit(Child);
syntax::Tree *ChildNode = Mapping.find(Child);
assert(ChildNode != nullptr);
setRole(ChildNode, Role);
}
const syntax::Token *syntax::TreeBuilder::findToken(SourceLocation L) const {
if (L.isInvalid())
return nullptr;
auto It = LocationToToken.find(L);
assert(It != LocationToToken.end());
return It->second;
}
syntax::TranslationUnit *syntax::buildSyntaxTree(Arena &A,
ASTContext &Context) {
TreeBuilder Builder(A);
BuildTreeVisitor(Context, Builder).TraverseAST(Context);
return std::move(Builder).finalize();
}
Reference in New Issue View Git Blame Copy Permalink