33 #include "llvm/ADT/ArrayRef.h"
34 #include "llvm/ADT/DenseMap.h"
35 #include "llvm/ADT/PointerUnion.h"
36 #include "llvm/ADT/STLExtras.h"
37 #include "llvm/ADT/ScopeExit.h"
38 #include "llvm/ADT/SmallVector.h"
39 #include "llvm/Support/Allocator.h"
40 #include "llvm/Support/Casting.h"
41 #include "llvm/Support/Compiler.h"
42 #include "llvm/Support/FormatVariadic.h"
43 #include "llvm/Support/MemoryBuffer.h"
44 #include "llvm/Support/raw_ostream.h"
48 using namespace clang;
54 if (
auto *C = dyn_cast<CXXConstructExpr>(E)) {
55 auto NumArgs = C->getNumArgs();
56 if (NumArgs == 1 || (NumArgs > 1 && isa<CXXDefaultArgExpr>(C->getArg(1)))) {
57 Expr *A = C->getArg(0);
58 if (C->getParenOrBraceRange().isInvalid())
73 if (
auto *F = dyn_cast<CXXFunctionalCastExpr>(E)) {
74 if (F->getCastKind() == CK_ConstructorConversion)
75 return F->getSubExpr();
102 struct GetStartLoc :
TypeLocVisitor<GetStartLoc, SourceLocation> {
112 return HandlePointer(T);
116 return HandlePointer(T);
120 return HandlePointer(T);
124 return HandlePointer(T);
128 return HandlePointer(T);
145 return VisitTypeLoc(T);
150 auto L = Visit(T.getPointeeLoc());
153 return T.getLocalSourceRange().getBegin();
159 auto FirstDefaultArg =
160 llvm::find_if(Args, [](
auto It) {
return isa<CXXDefaultArgExpr>(It); });
161 return llvm::make_range(Args.begin(), FirstDefaultArg);
168 case OO_ExclaimEqual:
170 case OO_GreaterEqual:
177 case OO_PercentEqual:
180 case OO_LessLessEqual:
181 case OO_GreaterGreaterEqual:
192 case OO_GreaterGreater:
197 return syntax::NodeKind::BinaryOperatorExpression;
200 return syntax::NodeKind::PrefixUnaryOperatorExpression;
206 return syntax::NodeKind::PrefixUnaryOperatorExpression;
208 return syntax::NodeKind::PostfixUnaryOperatorExpression;
210 llvm_unreachable(
"Invalid number of arguments for operator");
219 return syntax::NodeKind::PrefixUnaryOperatorExpression;
221 return syntax::NodeKind::BinaryOperatorExpression;
223 llvm_unreachable(
"Invalid number of arguments for operator");
225 return syntax::NodeKind::BinaryOperatorExpression;
230 case OO_Array_Delete:
234 return syntax::NodeKind::UnknownExpression;
236 return syntax::NodeKind::CallExpression;
240 llvm_unreachable(
"Not an overloadable operator");
242 llvm_unreachable(
"Unknown OverloadedOperatorKind enum");
251 assert((isa<DeclaratorDecl, TypedefNameDecl>(D)) &&
252 "only DeclaratorDecl and TypedefNameDecl are supported.");
255 bool IsAnonymous = DN.
isIdentifier() && !DN.getAsIdentifierInfo();
259 if (
const auto *DD = dyn_cast<DeclaratorDecl>(D)) {
260 if (DD->getQualifierLoc()) {
261 return DD->getQualifierLoc().getBeginLoc();
274 if (
auto *
V = dyn_cast<VarDecl>(D)) {
275 auto *I =
V->getInit();
277 if (I && !
V->isCXXForRangeDecl())
278 return I->getSourceRange();
297 if (Name.isValid()) {
307 assert(
SM.isBeforeInTranslationUnit(
End, InitializerEnd) ||
308 End == InitializerEnd);
309 End = InitializerEnd;
316 using ASTPtr = llvm::PointerUnion<Stmt *, Decl *>;
320 class ASTToSyntaxMapping {
323 assert(To !=
nullptr);
324 assert(!From.isNull());
326 bool Added =
Nodes.insert({From, To}).second;
328 assert(Added &&
"mapping added twice");
332 assert(To !=
nullptr);
335 bool Added = NNSNodes.insert({From, To}).second;
337 assert(Added &&
"mapping added twice");
343 return NNSNodes.lookup(
P);
347 llvm::DenseMap<ASTPtr, syntax::Tree *>
Nodes;
348 llvm::DenseMap<NestedNameSpecifierLoc, syntax::Tree *> NNSNodes;
372 Pending(
Arena, TBTM.tokenBuffer()) {
374 LocationToToken.insert({T.location(), &T});
379 return TBTM.sourceManager();
386 Pending.foldChildren(TBTM.tokenBuffer(), Range, New);
388 Mapping.add(From, New);
399 Pending.foldChildren(TBTM.tokenBuffer(), Range, New);
401 Mapping.add(From, New);
409 auto ListRange = Pending.shrinkToFitList(SuperRange);
410 Pending.foldChildren(TBTM.tokenBuffer(), ListRange, New);
412 Mapping.add(From, New);
441 auto Tokens = TBTM.tokenBuffer().expandedTokens();
442 assert(!Tokens.empty());
443 assert(Tokens.back().kind() ==
tok::eof);
446 Pending.foldChildren(TBTM.tokenBuffer(), Tokens.drop_back(),
449 auto *TU = cast<syntax::TranslationUnit>(std::move(Pending).
finalize());
450 TU->assertInvariantsRecursive();
459 assert(Range.isValid());
460 return getRange(Range.getBegin(), Range.getEnd());
468 assert(
First.isValid());
469 assert(
Last.isValid());
471 TBTM.sourceManager().isBeforeInTranslationUnit(
First,
Last));
478 return maybeAppendSemicolon(Tokens, D);
484 assert((isa<DeclaratorDecl, TypedefNameDecl>(D)) &&
485 "only DeclaratorDecl and TypedefNameDecl are supported.");
490 if (Next ==
nullptr) {
495 if (D->
getKind() != Next->getKind()) {
512 if (
const auto *S = dyn_cast<TagDecl>(D))
513 Tokens =
getRange(S->TypeDecl::getBeginLoc(), S->getEndLoc());
516 return maybeAppendSemicolon(Tokens, D);
526 auto Tokens =
getRange(S->getSourceRange());
527 if (isa<CompoundStmt>(S))
532 if (Tokens.back().kind() == tok::semi)
534 return withTrailingSemicolon(Tokens);
539 const Decl *D)
const {
540 if (isa<NamespaceDecl>(D))
542 if (DeclsWithoutSemicolons.count(D))
546 return withTrailingSemicolon(Tokens);
551 assert(!Tokens.empty());
552 assert(Tokens.back().kind() !=
tok::eof);
554 if (Tokens.back().kind() != tok::semi && Tokens.end()->kind() == tok::semi)
555 return llvm::makeArrayRef(Tokens.begin(), Tokens.end() + 1);
581 Trees.insert(Trees.end(), {&T, L});
586 assert(!
Range.empty());
587 auto It = Trees.lower_bound(
Range.begin());
588 assert(It != Trees.end() &&
"no node found");
589 assert(It->first ==
Range.begin() &&
"no child with the specified range");
590 assert((std::next(It) == Trees.end() ||
591 std::next(It)->first ==
Range.end()) &&
592 "no child with the specified range");
594 "re-assigning role for a child");
595 It->second->setRole(Role);
601 auto BeginChildren = Trees.lower_bound(
Range.begin());
602 assert((BeginChildren == Trees.end() ||
603 BeginChildren->first ==
Range.begin()) &&
604 "Range crosses boundaries of existing subtrees");
606 auto EndChildren = Trees.lower_bound(
Range.end());
608 (EndChildren == Trees.end() || EndChildren->first ==
Range.end()) &&
609 "Range crosses boundaries of existing subtrees");
611 auto BelongsToList = [](decltype(Trees)::value_type KV) {
612 auto Role = KV.second->getRole();
617 auto BeginListChildren =
618 std::find_if(BeginChildren, EndChildren, BelongsToList);
620 auto EndListChildren =
621 std::find_if_not(BeginListChildren, EndChildren, BelongsToList);
624 EndListChildren->first);
631 assert(
Node->getFirstChild() ==
nullptr &&
"node already has children");
633 auto *FirstToken = Tokens.begin();
634 auto BeginChildren = Trees.lower_bound(FirstToken);
636 assert((BeginChildren == Trees.end() ||
637 BeginChildren->first == FirstToken) &&
638 "fold crosses boundaries of existing subtrees");
639 auto EndChildren = Trees.lower_bound(Tokens.end());
641 (EndChildren == Trees.end() || EndChildren->first == Tokens.end()) &&
642 "fold crosses boundaries of existing subtrees");
644 for (
auto It = BeginChildren; It != EndChildren; ++It) {
645 auto *
C = It->second;
648 Node->appendChildLowLevel(C);
652 Node->Original =
true;
656 Trees.erase(BeginChildren, EndChildren);
657 Trees.insert({FirstToken,
Node});
662 assert(Trees.size() == 1);
663 auto *Root = Trees.begin()->second;
670 for (
auto It = Trees.begin(); It != Trees.end(); ++It) {
671 unsigned CoveredTokens =
673 ? (std::next(It)->first - It->first)
677 formatv(
"- '{0}' covers '{1}'+{2} tokens\n", It->second->getKind(),
679 R += It->second->dump(STM);
688 std::map<const syntax::Token *, syntax::Node *> Trees;
695 TokenBufferTokenManager& TBTM;
697 llvm::DenseMap<SourceLocation, const syntax::Token *> LocationToToken;
700 ASTToSyntaxMapping Mapping;
707 : Builder(Builder), Context(Context) {}
709 bool shouldTraversePostOrder()
const {
return true; }
712 return processDeclaratorAndDeclaration(DD);
716 return processDeclaratorAndDeclaration(TD);
719 bool VisitDecl(
Decl *D) {
721 Builder.foldNode(Builder.getDeclarationRange(D),
731 if (!RecursiveASTVisitor::TraverseClassTemplateSpecializationDecl(C))
733 if (
C->isExplicitSpecialization())
736 cast<syntax::SimpleDeclaration>(handleFreeStandingTagDecl(C));
737 foldExplicitTemplateInstantiation(
738 Builder.getTemplateRange(C), Builder.findToken(
C->getExternLoc()),
739 Builder.findToken(
C->getTemplateKeywordLoc()), Declaration, C);
744 foldTemplateDeclaration(
745 Builder.getDeclarationRange(S),
746 Builder.findToken(S->getTemplateParameters()->getTemplateLoc()),
747 Builder.getDeclarationRange(S->getTemplatedDecl()), S);
751 bool WalkUpFromTagDecl(
TagDecl *C) {
753 if (!
C->isFreeStanding()) {
754 assert(
C->getNumTemplateParameterLists() == 0);
757 handleFreeStandingTagDecl(C);
762 assert(
C->isFreeStanding());
764 auto DeclarationRange = Builder.getDeclarationRange(C);
766 Builder.foldNode(DeclarationRange, Result,
nullptr);
770 const auto *TemplateKW = Builder.findToken(L.getTemplateLoc());
771 auto R = llvm::makeArrayRef(TemplateKW, DeclarationRange.end());
773 foldTemplateDeclaration(R, TemplateKW, DeclarationRange,
nullptr);
774 DeclarationRange = R;
776 if (
auto *S = dyn_cast<ClassTemplatePartialSpecializationDecl>(C))
777 ConsumeTemplateParameters(*S->getTemplateParameters());
778 for (
unsigned I =
C->getNumTemplateParameterLists(); 0 < I; --I)
779 ConsumeTemplateParameters(*
C->getTemplateParameterList(I - 1));
792 Builder.markChildToken(S->getLBracLoc(), NodeRole::OpenParen);
793 for (
auto *Child : S->body())
794 Builder.markStmtChild(Child, NodeRole::Statement);
795 Builder.markChildToken(S->getRBracLoc(), NodeRole::CloseParen);
797 Builder.foldNode(Builder.getStmtRange(S),
803 bool WalkUpFromStmt(
Stmt *S) {
804 Builder.foldNode(Builder.getStmtRange(S),
809 bool TraverseIfStmt(
IfStmt *S) {
810 bool Result = [&,
this]() {
811 if (S->getInit() && !TraverseStmt(S->getInit())) {
817 if (S->hasVarStorage()) {
818 if (!TraverseStmt(S->getConditionVariableDeclStmt()))
820 }
else if (S->getCond() && !TraverseStmt(S->getCond()))
823 if (S->getThen() && !TraverseStmt(S->getThen()))
825 if (S->getElse() && !TraverseStmt(S->getElse()))
838 bool Result = [&,
this]() {
839 if (S->getInit() && !TraverseStmt(S->getInit()))
841 if (S->getLoopVariable() && !TraverseDecl(S->getLoopVariable()))
843 if (S->getRangeInit() && !TraverseStmt(S->getRangeInit()))
845 if (S->getBody() && !TraverseStmt(S->getBody()))
849 WalkUpFromCXXForRangeStmt(S);
853 bool TraverseStmt(
Stmt *S) {
854 if (
auto *DS = dyn_cast_or_null<DeclStmt>(S)) {
856 for (
auto *D : DS->decls())
857 Builder.noticeDeclWithoutSemicolon(D);
858 }
else if (
auto *E = dyn_cast_or_null<Expr>(S)) {
870 bool WalkUpFromExpr(
Expr *E) {
871 assert(!
isImplicitExpr(E) &&
"should be handled by TraverseStmt");
872 Builder.foldNode(Builder.getExprRange(E),
883 return WalkUpFromUserDefinedLiteral(S);
886 syntax::UserDefinedLiteralExpression *
888 switch (S->getLiteralOperatorKind()) {
890 return new (allocator()) syntax::IntegerUserDefinedLiteralExpression;
892 return new (allocator()) syntax::FloatUserDefinedLiteralExpression;
894 return new (allocator()) syntax::CharUserDefinedLiteralExpression;
896 return new (allocator()) syntax::StringUserDefinedLiteralExpression;
903 auto TokLoc = S->getBeginLoc();
910 if (
Literal.isIntegerLiteral())
911 return new (allocator()) syntax::IntegerUserDefinedLiteralExpression;
913 assert(
Literal.isFloatingLiteral());
914 return new (allocator()) syntax::FloatUserDefinedLiteralExpression;
917 llvm_unreachable(
"Unknown literal operator kind.");
922 Builder.foldNode(Builder.getExprRange(S), buildUserDefinedLiteral(S), S);
941 if (
auto DependentTL =
946 SR.
setBegin(DependentTL.getTemplateKeywordLoc());
956 return syntax::NodeKind::GlobalNameSpecifier;
960 return syntax::NodeKind::IdentifierNameSpecifier;
962 return syntax::NodeKind::SimpleTemplateNameSpecifier;
966 if (isa<DecltypeType>(NNSType))
967 return syntax::NodeKind::DecltypeNameSpecifier;
968 if (isa<TemplateSpecializationType, DependentTemplateSpecializationType>(
970 return syntax::NodeKind::SimpleTemplateNameSpecifier;
971 return syntax::NodeKind::IdentifierNameSpecifier;
975 llvm::report_fatal_error(
"We don't yet support the __super specifier",
980 syntax::NameSpecifier *
983 auto NameSpecifierTokens =
984 Builder.getRange(getLocalSourceRange(NNSLoc)).drop_back();
986 case syntax::NodeKind::GlobalNameSpecifier:
987 return new (allocator()) syntax::GlobalNameSpecifier;
988 case syntax::NodeKind::IdentifierNameSpecifier: {
989 assert(NameSpecifierTokens.size() == 1);
990 Builder.markChildToken(NameSpecifierTokens.begin(),
992 auto *NS =
new (allocator()) syntax::IdentifierNameSpecifier;
993 Builder.foldNode(NameSpecifierTokens, NS,
nullptr);
996 case syntax::NodeKind::SimpleTemplateNameSpecifier: {
1002 auto *NS =
new (allocator()) syntax::SimpleTemplateNameSpecifier;
1003 Builder.foldNode(NameSpecifierTokens, NS,
nullptr);
1006 case syntax::NodeKind::DecltypeNameSpecifier: {
1008 if (!RecursiveASTVisitor::TraverseDecltypeTypeLoc(TL))
1010 auto *NS =
new (allocator()) syntax::DecltypeNameSpecifier;
1015 Builder.foldNode(NameSpecifierTokens, NS,
nullptr);
1019 llvm_unreachable(
"getChildKind() does not return this value");
1030 for (
auto It = QualifierLoc; It; It = It.getPrefix()) {
1031 auto *NS = buildNameSpecifier(It);
1037 Builder.foldNode(Builder.getRange(QualifierLoc.
getSourceRange()),
1049 if (TemplateKeywordLoc.
isValid())
1050 Builder.markChildToken(TemplateKeywordLoc,
1055 Builder.foldNode(Builder.getRange(UnqualifiedIdLoc), TheUnqualifiedId,
1059 auto IdExpressionBeginLoc =
1062 auto *TheIdExpression =
new (allocator()) syntax::IdExpression;
1064 Builder.getRange(IdExpressionBeginLoc, UnqualifiedIdLoc.
getEnd()),
1065 TheIdExpression, From);
1067 return TheIdExpression;
1074 if (S->isImplicitAccess()) {
1075 buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),
1076 SourceRange(S->getMemberLoc(), S->getEndLoc()), S);
1080 auto *TheIdExpression = buildIdExpression(
1081 S->getQualifierLoc(), S->getTemplateKeywordLoc(),
1082 SourceRange(S->getMemberLoc(), S->getEndLoc()),
nullptr);
1089 Builder.foldNode(Builder.getExprRange(S),
1090 new (allocator()) syntax::MemberExpression, S);
1095 buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),
1096 SourceRange(S->getLocation(), S->getEndLoc()), S);
1103 buildIdExpression(S->getQualifierLoc(), S->getTemplateKeywordLoc(),
1104 SourceRange(S->getLocation(), S->getEndLoc()), S);
1110 if (!S->isImplicit()) {
1111 Builder.markChildToken(S->getLocation(),
1113 Builder.foldNode(Builder.getExprRange(S),
1114 new (allocator()) syntax::ThisExpression, S);
1119 bool WalkUpFromParenExpr(
ParenExpr *S) {
1123 Builder.foldNode(Builder.getExprRange(S),
1124 new (allocator()) syntax::ParenExpression, S);
1130 Builder.foldNode(Builder.getExprRange(S),
1131 new (allocator()) syntax::IntegerLiteralExpression, S);
1137 Builder.foldNode(Builder.getExprRange(S),
1138 new (allocator()) syntax::CharacterLiteralExpression, S);
1144 Builder.foldNode(Builder.getExprRange(S),
1145 new (allocator()) syntax::FloatingLiteralExpression, S);
1151 Builder.foldNode(Builder.getExprRange(S),
1152 new (allocator()) syntax::StringLiteralExpression, S);
1158 Builder.foldNode(Builder.getExprRange(S),
1159 new (allocator()) syntax::BoolLiteralExpression, S);
1165 Builder.foldNode(Builder.getExprRange(S),
1166 new (allocator()) syntax::CxxNullPtrExpression, S);
1171 Builder.markChildToken(S->getOperatorLoc(),
1176 Builder.foldNode(Builder.getExprRange(S),
1180 Builder.foldNode(Builder.getExprRange(S),
1189 Builder.markChildToken(S->getOperatorLoc(),
1192 Builder.foldNode(Builder.getExprRange(S),
1202 for (
auto *Arg : Args) {
1204 const auto *DelimiterToken =
1205 std::next(Builder.findToken(Arg->getEndLoc()));
1206 if (DelimiterToken->kind() == clang::tok::TokenKind::comma)
1212 Builder.foldNode(Builder.getRange((*Args.begin())->getBeginLoc(),
1213 (*(Args.end() - 1))->getEndLoc()),
1219 bool WalkUpFromCallExpr(
CallExpr *S) {
1222 const auto *LParenToken =
1223 std::next(Builder.findToken(S->getCallee()->getEndLoc()));
1226 if (LParenToken->kind() == clang::tok::l_paren)
1229 Builder.markChild(buildCallArguments(S->arguments()),
1234 Builder.foldNode(Builder.getRange(S->getSourceRange()),
1235 new (allocator()) syntax::CallExpression, S);
1241 if ((S->getNumArgs() == 0 || isa<CXXDefaultArgExpr>(S->getArg(0))) &&
1242 S->getParenOrBraceRange().isInvalid())
1244 return RecursiveASTVisitor::WalkUpFromCXXConstructExpr(S);
1252 for (
auto *child : S->arguments()) {
1259 if (child->getSourceRange().isInvalid()) {
1261 syntax::NodeKind::PostfixUnaryOperatorExpression);
1264 if (!TraverseStmt(child))
1267 return WalkUpFromCXXOperatorCallExpr(S);
1272 case syntax::NodeKind::BinaryOperatorExpression:
1274 Builder.markChildToken(S->getOperatorLoc(),
1277 Builder.foldNode(Builder.getExprRange(S),
1280 case syntax::NodeKind::PrefixUnaryOperatorExpression:
1281 Builder.markChildToken(S->getOperatorLoc(),
1284 Builder.foldNode(Builder.getExprRange(S),
1288 case syntax::NodeKind::PostfixUnaryOperatorExpression:
1289 Builder.markChildToken(S->getOperatorLoc(),
1292 Builder.foldNode(Builder.getExprRange(S),
1296 case syntax::NodeKind::CallExpression: {
1299 const auto *LParenToken =
1300 std::next(Builder.findToken(S->getArg(0)->getEndLoc()));
1303 if (LParenToken->kind() == clang::tok::l_paren)
1307 S->arg_begin() + 1, S->arg_end())),
1312 Builder.foldNode(Builder.getRange(S->getSourceRange()),
1313 new (allocator()) syntax::CallExpression, S);
1316 case syntax::NodeKind::UnknownExpression:
1317 return WalkUpFromExpr(S);
1319 llvm_unreachable(
"getOperatorNodeKind() does not return this value");
1326 auto Tokens = Builder.getDeclarationRange(S);
1327 if (Tokens.front().kind() == tok::coloncolon) {
1341 if (!WalkUpFromParenTypeLoc(L))
1366 for (
auto *
P : Params) {
1368 const auto *DelimiterToken = std::next(Builder.findToken(
P->getEndLoc()));
1369 if (DelimiterToken->kind() == clang::tok::TokenKind::comma)
1373 if (!Params.empty())
1374 Builder.foldNode(Builder.getRange(Params.front()->getBeginLoc(),
1375 Params.back()->getEndLoc()),
1383 Builder.markChild(buildParameterDeclarationList(L.
getParams()),
1394 return WalkUpFromFunctionTypeLoc(L);
1396 auto *TrailingReturnTokens = buildTrailingReturn(L);
1399 return WalkUpFromFunctionTypeLoc(L);
1407 if (!WalkUpFromMemberPointerTypeLoc(L))
1414 Builder.foldNode(Builder.getRange(SR),
1422 bool WalkUpFromDeclStmt(
DeclStmt *S) {
1423 Builder.foldNode(Builder.getStmtRange(S),
1428 bool WalkUpFromNullStmt(
NullStmt *S) {
1429 Builder.foldNode(Builder.getStmtRange(S),
1435 Builder.markChildToken(S->getSwitchLoc(),
1438 Builder.foldNode(Builder.getStmtRange(S),
1443 bool WalkUpFromCaseStmt(
CaseStmt *S) {
1444 Builder.markChildToken(S->getKeywordLoc(),
1448 Builder.foldNode(Builder.getStmtRange(S),
1454 Builder.markChildToken(S->getKeywordLoc(),
1457 Builder.foldNode(Builder.getStmtRange(S),
1462 bool WalkUpFromIfStmt(
IfStmt *S) {
1464 Stmt *ConditionStatement = S->getCond();
1465 if (S->hasVarStorage())
1466 ConditionStatement = S->getConditionVariableDeclStmt();
1471 Builder.foldNode(Builder.getStmtRange(S),
1476 bool WalkUpFromForStmt(
ForStmt *S) {
1479 Builder.foldNode(Builder.getStmtRange(S),
1484 bool WalkUpFromWhileStmt(
WhileStmt *S) {
1485 Builder.markChildToken(S->getWhileLoc(),
1488 Builder.foldNode(Builder.getStmtRange(S),
1494 Builder.markChildToken(S->getContinueLoc(),
1496 Builder.foldNode(Builder.getStmtRange(S),
1501 bool WalkUpFromBreakStmt(
BreakStmt *S) {
1502 Builder.markChildToken(S->getBreakLoc(),
1504 Builder.foldNode(Builder.getStmtRange(S),
1510 Builder.markChildToken(S->getReturnLoc(),
1513 Builder.foldNode(Builder.getStmtRange(S),
1521 Builder.foldNode(Builder.getStmtRange(S),
1526 bool WalkUpFromEmptyDecl(
EmptyDecl *S) {
1527 Builder.foldNode(Builder.getDeclarationRange(S),
1535 Builder.foldNode(Builder.getDeclarationRange(S),
1541 Builder.foldNode(Builder.getDeclarationRange(S),
1548 Builder.foldNode(Builder.getDeclarationRange(S),
1554 Builder.foldNode(Builder.getDeclarationRange(S),
1559 bool WalkUpFromUsingDecl(
UsingDecl *S) {
1560 Builder.foldNode(Builder.getDeclarationRange(S),
1566 Builder.foldNode(Builder.getDeclarationRange(S),
1572 Builder.foldNode(Builder.getDeclarationRange(S),
1578 Builder.foldNode(Builder.getDeclarationRange(S),
1586 template <
class T>
bool processDeclaratorAndDeclaration(T *D) {
1588 Builder.sourceManager(), D->getTypeSourceInfo()->getTypeLoc(),
1593 if (!
Range.getBegin().isValid()) {
1596 Builder.foldNode(Builder.getDeclarationRange(D),
1602 Builder.foldNode(Builder.getRange(Range), N,
nullptr);
1605 if (!Builder.isResponsibleForCreatingDeclaration(D)) {
1608 const auto *DelimiterToken = std::next(Builder.findToken(
Range.getEnd()));
1609 if (DelimiterToken->kind() == clang::tok::TokenKind::comma)
1613 auto DeclarationRange = Builder.getDeclarationRange(D);
1614 Builder.foldList(DeclarationRange, DL,
nullptr);
1617 Builder.foldNode(DeclarationRange,
1629 auto ReturnDeclaratorRange =
SourceRange(GetStartLoc().Visit(ReturnedType),
1630 ReturnedType.getEndLoc());
1632 if (ReturnDeclaratorRange.isValid()) {
1634 Builder.foldNode(Builder.getRange(ReturnDeclaratorRange),
1635 ReturnDeclarator,
nullptr);
1639 auto Return = Builder.getRange(ReturnedType.getSourceRange());
1640 const auto *Arrow = Return.begin() - 1;
1641 assert(Arrow->kind() == tok::arrow);
1642 auto Tokens = llvm::makeArrayRef(Arrow, Return.end());
1644 if (ReturnDeclarator)
1647 Builder.foldNode(Tokens, R, L);
1651 void foldExplicitTemplateInstantiation(
1655 assert(!ExternKW || ExternKW->
kind() == tok::kw_extern);
1656 assert(TemplateKW && TemplateKW->
kind() == tok::kw_template);
1667 assert(TemplateKW && TemplateKW->
kind() == tok::kw_template);
1671 Builder.foldNode(Range, N, From);
1677 llvm::BumpPtrAllocator &allocator() {
return Builder.allocator(); }
1685 DeclsWithoutSemicolons.insert(D);
1691 Pending.assignRole(*findToken(Loc), Role);
1697 Pending.assignRole(*T, R);
1706 auto *SN = Mapping.find(N);
1707 assert(SN !=
nullptr);
1711 auto *SN = Mapping.find(NNSLoc);
1712 assert(SN !=
nullptr);
1721 if (
Expr *ChildExpr = dyn_cast<Expr>(Child)) {
1724 markExprChild(ChildExpr, NodeRole::Expression);
1727 Pending.foldChildren(TBTM.tokenBuffer(), getStmtRange(Child), ChildNode);
1729 ChildNode = Mapping.find(Child);
1731 assert(ChildNode !=
nullptr);
1732 setRole(ChildNode, Role);
1741 assert(ChildNode !=
nullptr);
1742 setRole(ChildNode, Role);
1748 auto It = LocationToToken.find(L);
1749 assert(It != LocationToToken.end());
1757 BuildTreeVisitor(Context, Builder).TraverseAST(Context);
1758 return std::move(Builder).finalize();