13#include "clang/AST/ASTTypeTraits.h"
14#include "clang/AST/Expr.h"
15#include "clang/AST/ExprCXX.h"
16#include "clang/AST/NestedNameSpecifier.h"
17#include "clang/AST/PrettyPrinter.h"
18#include "clang/AST/RecursiveASTVisitor.h"
19#include "clang/AST/TextNodeDumper.h"
20#include "clang/AST/Type.h"
21#include "clang/AST/TypeLoc.h"
22#include "clang/Basic/Specifiers.h"
23#include "clang/Tooling/Syntax/Tokens.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/Support/raw_ostream.h"
32using llvm::raw_ostream;
33template <
typename Pr
int> std::string
toString(
const Print &
C) {
35 llvm::raw_string_ostream
OS(Result);
37 return std::move(
OS.str());
40bool isInjectedClassName(
Decl *D) {
41 if (
const auto *CRD = llvm::dyn_cast<CXXRecordDecl>(D))
42 return CRD->isInjectedClassName();
49 const syntax::TokenBuffer &Tokens;
50 const ASTContext &Ctx;
55 std::vector<ASTNode *> Stack;
60 bool traverseNodePre(llvm::StringRef
Role,
const T &Node) {
62 assert(
Root.role.empty());
63 Stack.push_back(&Root);
65 Stack.back()->children.emplace_back();
66 Stack.push_back(&Stack.back()->children.back());
68 auto &N = *Stack.back();
70 N.kind = getKind(Node);
71 N.detail = getDetail(Node);
72 N.range = getRange(Node);
73 N.arcana = getArcana(Node);
76 bool traverseNodePost() {
77 assert(!Stack.empty());
81 template <
typename T,
typename Callable>
82 bool traverseNode(llvm::StringRef
Role,
const T &Node,
const Callable &Body) {
83 traverseNodePre(
Role, Node);
85 return traverseNodePost();
91 template <
typename T> std::optional<Range> getRange(
const T &Node) {
92 SourceRange SR = getSourceRange(Node);
93 auto Spelled = Tokens.spelledForExpanded(Tokens.expandedTokens(SR));
97 Tokens.sourceManager(),
98 CharSourceRange::getCharRange(
Spelled->front().location(),
99 Spelled->back().endLocation()));
101 template <typename T, typename = decltype(std::declval<T>().getSourceRange())>
102 SourceRange getSourceRange(
const T &Node) {
103 return Node.getSourceRange();
105 template <
typename T,
106 typename =
decltype(std::declval<T *>()->getSourceRange())>
107 SourceRange getSourceRange(
const T *Node) {
108 return Node->getSourceRange();
111 SourceRange getSourceRange(
const TemplateName &Node) {
return SourceRange(); }
113 SourceRange getSourceRange(
const Attr *Node) {
return Node->getRange(); }
118 std::string getKind(
const Decl *D) {
return D->getDeclKindName(); }
119 std::string getKind(
const Stmt *S) {
120 std::string Result = S->getStmtClassName();
121 if (llvm::StringRef(Result).endswith(
"Stmt") ||
122 llvm::StringRef(Result).endswith(
"Expr"))
123 Result.resize(Result.size() - 4);
126 std::string getKind(
const TypeLoc &TL) {
128 if (TL.getTypeLocClass() == TypeLoc::Qualified)
130 return TL.getType()->getTypeClassName();
132 std::string getKind(
const TemplateArgumentLoc &TAL) {
133 switch (TAL.getArgument().getKind()) {
134#define TEMPLATE_ARGUMENT_KIND(X) \
135 case TemplateArgument::X: \
146#undef TEMPLATE_ARGUMENT_KIND
148 llvm_unreachable(
"Unhandled ArgKind enum");
150 std::string getKind(
const NestedNameSpecifierLoc &NNSL) {
151 assert(NNSL.getNestedNameSpecifier());
152 switch (NNSL.getNestedNameSpecifier()->getKind()) {
154 case NestedNameSpecifier::X: \
165 llvm_unreachable(
"Unhandled SpecifierKind enum");
167 std::string getKind(
const CXXCtorInitializer *CCI) {
168 if (CCI->isBaseInitializer())
169 return "BaseInitializer";
170 if (CCI->isDelegatingInitializer())
171 return "DelegatingInitializer";
172 if (CCI->isAnyMemberInitializer())
173 return "MemberInitializer";
174 llvm_unreachable(
"Unhandled CXXCtorInitializer type");
176 std::string getKind(
const TemplateName &TN) {
177 switch (TN.getKind()) {
178#define TEMPLATE_KIND(X) \
179 case TemplateName::X: \
191 llvm_unreachable(
"Unhandled NameKind enum");
193 std::string getKind(
const Attr *A) {
194 switch (
A->getKind()) {
198#include "clang/Basic/AttrList.inc"
201 llvm_unreachable(
"Unhandled attr::Kind enum");
203 std::string getKind(
const CXXBaseSpecifier &CBS) {
206 return getAccessSpelling(CBS.getAccessSpecifier()).str();
208 std::string getKind(
const ConceptReference *CR) {
218 std::string getDetail(
const Decl *D) {
219 const auto *ND = dyn_cast<NamedDecl>(D);
220 if (!ND || llvm::isa_and_nonnull<CXXConstructorDecl>(ND->getAsFunction()) ||
221 isa<CXXDestructorDecl>(ND))
225 return "(anonymous)";
228 std::string getDetail(
const Stmt *S) {
229 if (
const auto *DRE = dyn_cast<DeclRefExpr>(S))
230 return DRE->getNameInfo().getAsString();
231 if (
const auto *DSDRE = dyn_cast<DependentScopeDeclRefExpr>(S))
232 return DSDRE->getNameInfo().getAsString();
233 if (
const auto *ME = dyn_cast<MemberExpr>(S))
234 return ME->getMemberNameInfo().getAsString();
235 if (
const auto *
CE = dyn_cast<CastExpr>(S))
236 return CE->getCastKindName();
237 if (
const auto *BO = dyn_cast<BinaryOperator>(S))
238 return BO->getOpcodeStr().str();
239 if (
const auto *UO = dyn_cast<UnaryOperator>(S))
240 return UnaryOperator::getOpcodeStr(UO->getOpcode()).str();
241 if (
const auto *CCO = dyn_cast<CXXConstructExpr>(S))
242 return CCO->getConstructor()->getNameAsString();
243 if (
const auto *CTE = dyn_cast<CXXThisExpr>(S)) {
244 bool Const = CTE->getType()->getPointeeType().isLocalConstQualified();
245 if (CTE->isImplicit())
246 return Const ?
"const, implicit" :
"implicit";
251 if (isa<IntegerLiteral, FloatingLiteral, FixedPointLiteral,
252 CharacterLiteral, ImaginaryLiteral, CXXBoolLiteralExpr>(S))
254 S->printPretty(
OS,
nullptr, Ctx.getPrintingPolicy());
256 if (
const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(S))
257 return MTE->isBoundToLvalueReference() ?
"lvalue" :
"rvalue";
260 std::string getDetail(
const TypeLoc &TL) {
261 if (TL.getType().hasLocalQualifiers())
262 return TL.getType().getLocalQualifiers().getAsString(
263 Ctx.getPrintingPolicy());
264 if (
const auto *TT = dyn_cast<TagType>(TL.getTypePtr()))
265 return getDetail(TT->getDecl());
266 if (
const auto *DT = dyn_cast<DeducedType>(TL.getTypePtr()))
268 return DT->getDeducedType().getAsString(Ctx.getPrintingPolicy());
269 if (
const auto *BT = dyn_cast<BuiltinType>(TL.getTypePtr()))
270 return BT->getName(Ctx.getPrintingPolicy()).str();
271 if (
const auto *TTPT = dyn_cast<TemplateTypeParmType>(TL.getTypePtr()))
272 return getDetail(TTPT->getDecl());
273 if (
const auto *TT = dyn_cast<TypedefType>(TL.getTypePtr()))
274 return getDetail(TT->getDecl());
277 std::string getDetail(
const NestedNameSpecifierLoc &NNSL) {
278 const auto &NNS = *NNSL.getNestedNameSpecifier();
279 switch (NNS.getKind()) {
280 case NestedNameSpecifier::Identifier:
281 return NNS.getAsIdentifier()->getName().str() +
"::";
282 case NestedNameSpecifier::Namespace:
283 return NNS.getAsNamespace()->getNameAsString() +
"::";
284 case NestedNameSpecifier::NamespaceAlias:
285 return NNS.getAsNamespaceAlias()->getNameAsString() +
"::";
290 std::string getDetail(
const CXXCtorInitializer *CCI) {
291 if (FieldDecl *FD = CCI->getAnyMember())
292 return getDetail(FD);
293 if (TypeLoc TL = CCI->getBaseClassLoc())
294 return getDetail(TL);
297 std::string getDetail(
const TemplateArgumentLoc &TAL) {
298 if (TAL.getArgument().getKind() == TemplateArgument::Integral)
299 return toString(TAL.getArgument().getAsIntegral(), 10);
302 std::string getDetail(
const TemplateName &TN) {
304 TN.print(
OS, Ctx.getPrintingPolicy(), TemplateName::Qualified::None);
307 std::string getDetail(
const Attr *A) {
308 return A->getAttrName() ?
A->getNormalizedFullName() :
A->getSpelling();
310 std::string getDetail(
const CXXBaseSpecifier &CBS) {
311 return CBS.isVirtual() ?
"virtual" :
"";
313 std::string getDetail(
const ConceptReference *CR) {
314 return CR->getNamedConcept()->getNameAsString();
319 template <
typename Dump> std::string dump(
const Dump &D) {
321 TextNodeDumper Dumper(
OS, Ctx,
false);
325 template <
typename T> std::string getArcana(
const T &N) {
326 return dump([&](TextNodeDumper &D) { D.Visit(N); });
328 std::string getArcana(
const NestedNameSpecifierLoc &NNS) {
return ""; }
329 std::string getArcana(
const TemplateName &NNS) {
return ""; }
330 std::string getArcana(
const CXXBaseSpecifier &CBS) {
return ""; }
331 std::string getArcana(
const TemplateArgumentLoc &TAL) {
332 return dump([&](TextNodeDumper &D) {
333 D.Visit(TAL.getArgument(), TAL.getSourceRange());
336 std::string getArcana(
const TypeLoc &TL) {
337 return dump([&](TextNodeDumper &D) { D.Visit(TL.getType()); });
342 DumpVisitor(
const syntax::TokenBuffer &Tokens,
const ASTContext &Ctx)
343 : Tokens(Tokens), Ctx(Ctx) {}
348 bool TraverseDecl(
Decl *D) {
349 return !D || isInjectedClassName(D) ||
350 traverseNode(
"declaration", D, [&] { Base::TraverseDecl(D); });
352 bool TraverseTypeLoc(TypeLoc TL) {
353 return !TL || traverseNode(
"type", TL, [&] { Base::TraverseTypeLoc(TL); });
355 bool TraverseTemplateName(
const TemplateName &TN) {
356 return traverseNode(
"template name", TN,
357 [&] { Base::TraverseTemplateName(TN); });
359 bool TraverseTemplateArgumentLoc(
const TemplateArgumentLoc &TAL) {
360 return traverseNode(
"template argument", TAL,
361 [&] { Base::TraverseTemplateArgumentLoc(TAL); });
363 bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSL) {
364 return !NNSL || traverseNode(
"specifier", NNSL, [&] {
365 Base::TraverseNestedNameSpecifierLoc(NNSL);
368 bool TraverseConstructorInitializer(CXXCtorInitializer *CCI) {
369 return !CCI || traverseNode(
"constructor initializer", CCI, [&] {
370 Base::TraverseConstructorInitializer(CCI);
373 bool TraverseAttr(Attr *A) {
374 return !
A || traverseNode(
"attribute", A, [&] { Base::TraverseAttr(A); });
376 bool TraverseConceptReference(ConceptReference *
C) {
377 return !
C || traverseNode(
"reference",
C,
378 [&] { Base::TraverseConceptReference(
C); });
380 bool TraverseCXXBaseSpecifier(
const CXXBaseSpecifier &CBS) {
381 return traverseNode(
"base", CBS,
382 [&] { Base::TraverseCXXBaseSpecifier(CBS); });
385 bool dataTraverseStmtPre(Stmt *S) {
386 return S && traverseNodePre(isa<Expr>(S) ?
"expression" :
"statement", S);
388 bool dataTraverseStmtPost(Stmt *
X) {
return traverseNodePost(); }
395 bool TraverseQualifiedTypeLoc(QualifiedTypeLoc QTL) {
396 return TraverseTypeLoc(QTL.getUnqualifiedLoc());
399 bool TraverseNestedNameSpecifier(NestedNameSpecifier *) {
return true; }
400 bool TraverseType(QualType) {
return true; }
403 bool TraverseOpaqueValueExpr(OpaqueValueExpr *
E) {
404 return TraverseStmt(
E->getSourceExpr());
407 bool TraversePseudoObjectExpr(PseudoObjectExpr *
E) {
408 return TraverseStmt(
E->getSyntacticForm());
415 const ASTContext &Ctx) {
416 DumpVisitor V(Tokens, Ctx);
418 if (
const auto *D = N.get<
Decl>())
419 V.TraverseDecl(
const_cast<Decl *
>(D));
420 else if (
const auto *S = N.get<Stmt>())
421 V.TraverseStmt(
const_cast<Stmt *
>(S));
422 else if (
const auto *NNSL = N.get<NestedNameSpecifierLoc>())
423 V.TraverseNestedNameSpecifierLoc(
424 *
const_cast<NestedNameSpecifierLoc *
>(NNSL));
425 else if (
const auto *NNS = N.get<NestedNameSpecifier>())
426 V.TraverseNestedNameSpecifier(
const_cast<NestedNameSpecifier *
>(NNS));
427 else if (
const auto *TL = N.get<TypeLoc>())
428 V.TraverseTypeLoc(*
const_cast<TypeLoc *
>(TL));
429 else if (
const auto *QT = N.get<QualType>())
430 V.TraverseType(*
const_cast<QualType *
>(QT));
431 else if (
const auto *CCI = N.get<CXXCtorInitializer>())
432 V.TraverseConstructorInitializer(
const_cast<CXXCtorInitializer *
>(CCI));
433 else if (
const auto *TAL = N.get<TemplateArgumentLoc>())
434 V.TraverseTemplateArgumentLoc(*
const_cast<TemplateArgumentLoc *
>(TAL));
435 else if (
const auto *CBS = N.get<CXXBaseSpecifier>())
436 V.TraverseCXXBaseSpecifier(*
const_cast<CXXBaseSpecifier *
>(CBS));
437 else if (
const auto *CR = N.get<ConceptReference>())
438 V.TraverseConceptReference(
const_cast<ConceptReference *
>(CR));
440 elog(
"dumpAST: unhandled DynTypedNode kind {0}",
441 N.getNodeKind().asStringRef());
442 return std::move(V.Root);
ArrayRef< const ParmVarDecl * > Pack
const FunctionDecl * Decl
#define TEMPLATE_ARGUMENT_KIND(X)
::clang::DynTypedNode Node
llvm::raw_string_ostream OS
index::SymbolRoleSet Role
Range halfOpenToRange(const SourceManager &SM, CharSourceRange R)
ASTNode dumpAST(const DynTypedNode &N, const syntax::TokenBuffer &Tokens, const ASTContext &Ctx)
static const char * toString(OffsetEncoding OE)
@ Type
An inlay hint that for a type annotation.
void elog(const char *Fmt, Ts &&... Vals)
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Simplified description of a clang AST node.