Debian Codegraph @

src/TemplateUtils.cpp

raw
1 /*
2 SPDX-FileCopyrightText: 2016 Sergio Martins <[email protected]>
3
4 SPDX-License-Identifier: LGPL-2.0-or-later
5 */
6
7 #include "TemplateUtils.h"
8 #include "StringUtils.h"
9
10 #include <clang/AST/Decl.h>
11 #include <clang/AST/DeclCXX.h>
12 #include <clang/AST/DeclTemplate.h>
13 #include <clang/AST/TemplateBase.h>
14 #include <clang/AST/Type.h>
15 #include <clang/Basic/LLVM.h>
16 #include <llvm/Support/Casting.h>
17
18 namespace clang
19 {
20 class LangOptions;
21 } // namespace clang
22
23 using namespace clang;
24
25 static std::vector<QualType> typesFromTemplateArguments(const TemplateArgumentList *templateArgs)
26 {
27 std::vector<QualType> result;
28 const int numArgs = templateArgs->size();
29 result.reserve(numArgs);
30 for (int i = 0; i < numArgs; ++i) {
31 const TemplateArgument &arg = templateArgs->get(i);
32 if (arg.getKind() == TemplateArgument::Type) {
33 result.push_back(arg.getAsType());
34 }
35 }
36
37 return result;
38 }
39
40 std::vector<QualType> clazy::getTemplateArgumentsTypes(CXXMethodDecl *method)
41 {
42 if (!method) {
43 return {};
44 }
45
46 const FunctionTemplateSpecializationInfo *specializationInfo = method->getTemplateSpecializationInfo();
47 if (!specializationInfo || !specializationInfo->TemplateArguments) {
48 return {};
49 }
50
51 return typesFromTemplateArguments(specializationInfo->TemplateArguments);
52 }
53
54 std::vector<clang::QualType> clazy::getTemplateArgumentsTypes(CXXRecordDecl *record)
55 {
56 if (!record) {
57 return {};
58 }
59
60 auto *templateDecl = dyn_cast<ClassTemplateSpecializationDecl>(record);
61 if (!templateDecl) {
62 return {};
63 }
64
65 return typesFromTemplateArguments(&(templateDecl->getTemplateInstantiationArgs()));
66 }
67
68 ClassTemplateSpecializationDecl *clazy::templateDecl(Decl *decl)
69 {
70 if (isa<ClassTemplateSpecializationDecl>(decl)) {
71 return dyn_cast<ClassTemplateSpecializationDecl>(decl);
72 }
73
74 auto *varDecl = dyn_cast<VarDecl>(decl);
75 if (!varDecl) {
76 return nullptr;
77 }
78 QualType qt = varDecl->getType();
79 const Type *t = qt.getTypePtrOrNull();
80 if (!t) {
81 return nullptr;
82 }
83 CXXRecordDecl *classDecl = t->getAsCXXRecordDecl();
84 if (!classDecl) {
85 return nullptr;
86 }
87 return dyn_cast<ClassTemplateSpecializationDecl>(classDecl);
88 }
89
90 std::string clazy::getTemplateArgumentTypeStr(ClassTemplateSpecializationDecl *specialization, unsigned int index, const LangOptions &lo, bool recordOnly)
91 {
92 if (!specialization) {
93 return {};
94 }
95
96 const auto &args = specialization->getTemplateArgs();
97 if (args.size() <= index) {
98 return {};
99 }
100
101 QualType qt = args[index].getAsType();
102 if (recordOnly) {
103 const Type *t = qt.getTypePtrOrNull();
104 if (!t || !t->getAsCXXRecordDecl()) {
105 return {};
106 }
107 }
108
109 return clazy::simpleTypeName(args[index].getAsType(), lo);
110 }
111
112 clang::QualType clazy::getTemplateArgumentType(ClassTemplateSpecializationDecl *specialization, unsigned int index)
113 {
114 if (!specialization) {
115 return {};
116 }
117
118 const auto &args = specialization->getTemplateArgs();
119 if (args.size() <= index) {
120 return {};
121 }
122
123 return args[index].getAsType();
124 }