clang  15.0.0git
QualTypeNames.cpp
Go to the documentation of this file.
1 //===------- QualTypeNames.cpp - Generate Complete QualType Names ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
11 #include "clang/AST/GlobalDecl.h"
12 #include "clang/AST/Mangle.h"
14 
15 #include <stdio.h>
16 #include <memory>
17 
18 namespace clang {
19 
20 namespace TypeName {
21 
22 /// Create a NestedNameSpecifier for Namesp and its enclosing
23 /// scopes.
24 ///
25 /// \param[in] Ctx - the AST Context to be used.
26 /// \param[in] Namesp - the NamespaceDecl for which a NestedNameSpecifier
27 /// is requested.
28 /// \param[in] WithGlobalNsPrefix - Indicate whether the global namespace
29 /// specifier "::" should be prepended or not.
30 static NestedNameSpecifier *createNestedNameSpecifier(
31  const ASTContext &Ctx,
32  const NamespaceDecl *Namesp,
33  bool WithGlobalNsPrefix);
34 
35 /// Create a NestedNameSpecifier for TagDecl and its enclosing
36 /// scopes.
37 ///
38 /// \param[in] Ctx - the AST Context to be used.
39 /// \param[in] TD - the TagDecl for which a NestedNameSpecifier is
40 /// requested.
41 /// \param[in] FullyQualify - Convert all template arguments into fully
42 /// qualified names.
43 /// \param[in] WithGlobalNsPrefix - Indicate whether the global namespace
44 /// specifier "::" should be prepended or not.
45 static NestedNameSpecifier *createNestedNameSpecifier(
46  const ASTContext &Ctx, const TypeDecl *TD,
47  bool FullyQualify, bool WithGlobalNsPrefix);
48 
49 static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
50  const ASTContext &Ctx, const Decl *decl,
51  bool FullyQualified, bool WithGlobalNsPrefix);
52 
53 static NestedNameSpecifier *getFullyQualifiedNestedNameSpecifier(
54  const ASTContext &Ctx, NestedNameSpecifier *scope, bool WithGlobalNsPrefix);
55 
57  TemplateName &TName,
58  bool WithGlobalNsPrefix) {
59  bool Changed = false;
60  NestedNameSpecifier *NNS = nullptr;
61 
62  TemplateDecl *ArgTDecl = TName.getAsTemplateDecl();
63  // ArgTDecl won't be NULL because we asserted that this isn't a
64  // dependent context very early in the call chain.
65  assert(ArgTDecl != nullptr);
67 
68  if (QTName && !QTName->hasTemplateKeyword()) {
69  NNS = QTName->getQualifier();
71  Ctx, NNS, WithGlobalNsPrefix);
72  if (QNNS != NNS) {
73  Changed = true;
74  NNS = QNNS;
75  } else {
76  NNS = nullptr;
77  }
78  } else {
80  Ctx, ArgTDecl, true, WithGlobalNsPrefix);
81  }
82  if (NNS) {
83  TemplateName UnderlyingTN(ArgTDecl);
84  if (UsingShadowDecl *USD = TName.getAsUsingShadowDecl())
85  UnderlyingTN = TemplateName(USD);
86  TName =
88  /*TemplateKeyword=*/false, UnderlyingTN);
89  Changed = true;
90  }
91  return Changed;
92 }
93 
95  TemplateArgument &Arg,
96  bool WithGlobalNsPrefix) {
97  bool Changed = false;
98 
99  // Note: we do not handle TemplateArgument::Expression, to replace it
100  // we need the information for the template instance decl.
101 
102  if (Arg.getKind() == TemplateArgument::Template) {
103  TemplateName TName = Arg.getAsTemplate();
104  Changed = getFullyQualifiedTemplateName(Ctx, TName, WithGlobalNsPrefix);
105  if (Changed) {
106  Arg = TemplateArgument(TName);
107  }
108  } else if (Arg.getKind() == TemplateArgument::Type) {
109  QualType SubTy = Arg.getAsType();
110  // Check if the type needs more desugaring and recurse.
111  QualType QTFQ = getFullyQualifiedType(SubTy, Ctx, WithGlobalNsPrefix);
112  if (QTFQ != SubTy) {
113  Arg = TemplateArgument(QTFQ);
114  Changed = true;
115  }
116  }
117  return Changed;
118 }
119 
121  const Type *TypePtr,
122  bool WithGlobalNsPrefix) {
123  // DependentTemplateTypes exist within template declarations and
124  // definitions. Therefore we shouldn't encounter them at the end of
125  // a translation unit. If we do, the caller has made an error.
126  assert(!isa<DependentTemplateSpecializationType>(TypePtr));
127  // In case of template specializations, iterate over the arguments
128  // and fully qualify them as well.
129  if (const auto *TST = dyn_cast<const TemplateSpecializationType>(TypePtr)) {
130  bool MightHaveChanged = false;
132  for (TemplateSpecializationType::iterator I = TST->begin(), E = TST->end();
133  I != E; ++I) {
134  // Cheap to copy and potentially modified by
135  // getFullyQualifedTemplateArgument.
136  TemplateArgument Arg(*I);
137  MightHaveChanged |= getFullyQualifiedTemplateArgument(
138  Ctx, Arg, WithGlobalNsPrefix);
139  FQArgs.push_back(Arg);
140  }
141 
142  // If a fully qualified arg is different from the unqualified arg,
143  // allocate new type in the AST.
144  if (MightHaveChanged) {
146  TST->getTemplateName(), FQArgs,
147  TST->getCanonicalTypeInternal());
148  // getTemplateSpecializationType returns a fully qualified
149  // version of the specialization itself, so no need to qualify
150  // it.
151  return QT.getTypePtr();
152  }
153  } else if (const auto *TSTRecord = dyn_cast<const RecordType>(TypePtr)) {
154  // We are asked to fully qualify and we have a Record Type,
155  // which can point to a template instantiation with no sugar in any of
156  // its template argument, however we still need to fully qualify them.
157 
158  if (const auto *TSTDecl =
159  dyn_cast<ClassTemplateSpecializationDecl>(TSTRecord->getDecl())) {
160  const TemplateArgumentList &TemplateArgs = TSTDecl->getTemplateArgs();
161 
162  bool MightHaveChanged = false;
164  for (unsigned int I = 0, E = TemplateArgs.size(); I != E; ++I) {
165  // cheap to copy and potentially modified by
166  // getFullyQualifedTemplateArgument
167  TemplateArgument Arg(TemplateArgs[I]);
168  MightHaveChanged |= getFullyQualifiedTemplateArgument(
169  Ctx, Arg, WithGlobalNsPrefix);
170  FQArgs.push_back(Arg);
171  }
172 
173  // If a fully qualified arg is different from the unqualified arg,
174  // allocate new type in the AST.
175  if (MightHaveChanged) {
176  TemplateName TN(TSTDecl->getSpecializedTemplate());
178  TN, FQArgs,
179  TSTRecord->getCanonicalTypeInternal());
180  // getTemplateSpecializationType returns a fully qualified
181  // version of the specialization itself, so no need to qualify
182  // it.
183  return QT.getTypePtr();
184  }
185  }
186  }
187  return TypePtr;
188 }
189 
190 static NestedNameSpecifier *createOuterNNS(const ASTContext &Ctx, const Decl *D,
191  bool FullyQualify,
192  bool WithGlobalNsPrefix) {
193  const DeclContext *DC = D->getDeclContext();
194  if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
195  while (NS && NS->isInline()) {
196  // Ignore inline namespace;
197  NS = dyn_cast<NamespaceDecl>(NS->getDeclContext());
198  }
199  if (NS && NS->getDeclName()) {
200  return createNestedNameSpecifier(Ctx, NS, WithGlobalNsPrefix);
201  }
202  return nullptr; // no starting '::', no anonymous
203  } else if (const auto *TD = dyn_cast<TagDecl>(DC)) {
204  return createNestedNameSpecifier(Ctx, TD, FullyQualify, WithGlobalNsPrefix);
205  } else if (const auto *TDD = dyn_cast<TypedefNameDecl>(DC)) {
207  Ctx, TDD, FullyQualify, WithGlobalNsPrefix);
208  } else if (WithGlobalNsPrefix && DC->isTranslationUnit()) {
210  }
211  return nullptr; // no starting '::' if |WithGlobalNsPrefix| is false
212 }
213 
214 /// Return a fully qualified version of this name specifier.
216  const ASTContext &Ctx, NestedNameSpecifier *Scope,
217  bool WithGlobalNsPrefix) {
218  switch (Scope->getKind()) {
220  // Already fully qualified
221  return Scope;
224  Ctx, Scope->getAsNamespace(), WithGlobalNsPrefix);
226  // Namespace aliases are only valid for the duration of the
227  // scope where they were introduced, and therefore are often
228  // invalid at the end of the TU. So use the namespace name more
229  // likely to be valid at the end of the TU.
231  Ctx,
232  Scope->getAsNamespaceAlias()->getNamespace()->getCanonicalDecl(),
233  WithGlobalNsPrefix);
235  // A function or some other construct that makes it un-namable
236  // at the end of the TU. Skip the current component of the name,
237  // but use the name of it's prefix.
239  Ctx, Scope->getPrefix(), WithGlobalNsPrefix);
243  const Type *Type = Scope->getAsType();
244  // Find decl context.
245  const TagDecl *TD = nullptr;
246  if (const TagType *TagDeclType = Type->getAs<TagType>()) {
247  TD = TagDeclType->getDecl();
248  } else {
249  TD = Type->getAsCXXRecordDecl();
250  }
251  if (TD) {
253  true /*FullyQualified*/,
254  WithGlobalNsPrefix);
255  } else if (const auto *TDD = dyn_cast<TypedefType>(Type)) {
256  return TypeName::createNestedNameSpecifier(Ctx, TDD->getDecl(),
257  true /*FullyQualified*/,
258  WithGlobalNsPrefix);
259  }
260  return Scope;
261  }
262  }
263  llvm_unreachable("bad NNS kind");
264 }
265 
266 /// Create a nested name specifier for the declaring context of
267 /// the type.
269  const ASTContext &Ctx, const Decl *Decl,
270  bool FullyQualified, bool WithGlobalNsPrefix) {
271  assert(Decl);
272 
274  const auto *Outer = dyn_cast_or_null<NamedDecl>(DC);
275  const auto *OuterNS = dyn_cast_or_null<NamespaceDecl>(DC);
276  if (Outer && !(OuterNS && OuterNS->isAnonymousNamespace())) {
277  if (const auto *CxxDecl = dyn_cast<CXXRecordDecl>(DC)) {
278  if (ClassTemplateDecl *ClassTempl =
279  CxxDecl->getDescribedClassTemplate()) {
280  // We are in the case of a type(def) that was declared in a
281  // class template but is *not* type dependent. In clang, it
282  // gets attached to the class template declaration rather than
283  // any specific class template instantiation. This result in
284  // 'odd' fully qualified typename:
285  //
286  // vector<_Tp,_Alloc>::size_type
287  //
288  // Make the situation is 'useable' but looking a bit odd by
289  // picking a random instance as the declaring context.
290  if (ClassTempl->spec_begin() != ClassTempl->spec_end()) {
291  Decl = *(ClassTempl->spec_begin());
292  Outer = dyn_cast<NamedDecl>(Decl);
293  OuterNS = dyn_cast<NamespaceDecl>(Decl);
294  }
295  }
296  }
297 
298  if (OuterNS) {
299  return createNestedNameSpecifier(Ctx, OuterNS, WithGlobalNsPrefix);
300  } else if (const auto *TD = dyn_cast<TagDecl>(Outer)) {
302  Ctx, TD, FullyQualified, WithGlobalNsPrefix);
303  } else if (isa<TranslationUnitDecl>(Outer)) {
304  // Context is the TU. Nothing needs to be done.
305  return nullptr;
306  } else {
307  // Decl's context was neither the TU, a namespace, nor a
308  // TagDecl, which means it is a type local to a scope, and not
309  // accessible at the end of the TU.
310  return nullptr;
311  }
312  } else if (WithGlobalNsPrefix && DC->isTranslationUnit()) {
314  }
315  return nullptr;
316 }
317 
318 /// Create a nested name specifier for the declaring context of
319 /// the type.
321  const ASTContext &Ctx, const Type *TypePtr,
322  bool FullyQualified, bool WithGlobalNsPrefix) {
323  if (!TypePtr) return nullptr;
324 
325  Decl *Decl = nullptr;
326  // There are probably other cases ...
327  if (const auto *TDT = dyn_cast<TypedefType>(TypePtr)) {
328  Decl = TDT->getDecl();
329  } else if (const auto *TagDeclType = dyn_cast<TagType>(TypePtr)) {
330  Decl = TagDeclType->getDecl();
331  } else if (const auto *TST = dyn_cast<TemplateSpecializationType>(TypePtr)) {
332  Decl = TST->getTemplateName().getAsTemplateDecl();
333  } else {
334  Decl = TypePtr->getAsCXXRecordDecl();
335  }
336 
337  if (!Decl) return nullptr;
338 
340  Ctx, Decl, FullyQualified, WithGlobalNsPrefix);
341 }
342 
344  const NamespaceDecl *Namespace,
345  bool WithGlobalNsPrefix) {
346  while (Namespace && Namespace->isInline()) {
347  // Ignore inline namespace;
348  Namespace = dyn_cast<NamespaceDecl>(Namespace->getDeclContext());
349  }
350  if (!Namespace) return nullptr;
351 
352  bool FullyQualified = true; // doesn't matter, DeclContexts are namespaces
354  Ctx,
355  createOuterNNS(Ctx, Namespace, FullyQualified, WithGlobalNsPrefix),
356  Namespace);
357 }
358 
360  const TypeDecl *TD,
361  bool FullyQualify,
362  bool WithGlobalNsPrefix) {
363  const Type *TypePtr = TD->getTypeForDecl();
364  if (isa<const TemplateSpecializationType>(TypePtr) ||
365  isa<const RecordType>(TypePtr)) {
366  // We are asked to fully qualify and we have a Record Type (which
367  // may point to a template specialization) or Template
368  // Specialization Type. We need to fully qualify their arguments.
369 
370  TypePtr = getFullyQualifiedTemplateType(Ctx, TypePtr, WithGlobalNsPrefix);
371  }
372 
374  Ctx, createOuterNNS(Ctx, TD, FullyQualify, WithGlobalNsPrefix),
375  false /*No TemplateKeyword*/, TypePtr);
376 }
377 
378 /// Return the fully qualified type, including fully-qualified
379 /// versions of any template parameters.
381  bool WithGlobalNsPrefix) {
382  // In case of myType* we need to strip the pointer first, fully
383  // qualify and attach the pointer once again.
384  if (isa<PointerType>(QT.getTypePtr())) {
385  // Get the qualifiers.
386  Qualifiers Quals = QT.getQualifiers();
387  QT = getFullyQualifiedType(QT->getPointeeType(), Ctx, WithGlobalNsPrefix);
388  QT = Ctx.getPointerType(QT);
389  // Add back the qualifiers.
390  QT = Ctx.getQualifiedType(QT, Quals);
391  return QT;
392  }
393 
394  if (auto *MPT = dyn_cast<MemberPointerType>(QT.getTypePtr())) {
395  // Get the qualifiers.
396  Qualifiers Quals = QT.getQualifiers();
397  // Fully qualify the pointee and class types.
398  QT = getFullyQualifiedType(QT->getPointeeType(), Ctx, WithGlobalNsPrefix);
399  QualType Class = getFullyQualifiedType(QualType(MPT->getClass(), 0), Ctx,
400  WithGlobalNsPrefix);
401  QT = Ctx.getMemberPointerType(QT, Class.getTypePtr());
402  // Add back the qualifiers.
403  QT = Ctx.getQualifiedType(QT, Quals);
404  return QT;
405  }
406 
407  // In case of myType& we need to strip the reference first, fully
408  // qualify and attach the reference once again.
409  if (isa<ReferenceType>(QT.getTypePtr())) {
410  // Get the qualifiers.
411  bool IsLValueRefTy = isa<LValueReferenceType>(QT.getTypePtr());
412  Qualifiers Quals = QT.getQualifiers();
413  QT = getFullyQualifiedType(QT->getPointeeType(), Ctx, WithGlobalNsPrefix);
414  // Add the r- or l-value reference type back to the fully
415  // qualified one.
416  if (IsLValueRefTy)
417  QT = Ctx.getLValueReferenceType(QT);
418  else
419  QT = Ctx.getRValueReferenceType(QT);
420  // Add back the qualifiers.
421  QT = Ctx.getQualifiedType(QT, Quals);
422  return QT;
423  }
424 
425  // We don't consider the alias introduced by `using a::X` as a new type.
426  // The qualified name is still a::X.
427  if (isa<UsingType>(QT.getTypePtr())) {
429  WithGlobalNsPrefix);
430  }
431 
432  // Remove the part of the type related to the type being a template
433  // parameter (we won't report it as part of the 'type name' and it
434  // is actually make the code below to be more complex (to handle
435  // those)
436  while (isa<SubstTemplateTypeParmType>(QT.getTypePtr())) {
437  // Get the qualifiers.
438  Qualifiers Quals = QT.getQualifiers();
439 
440  QT = cast<SubstTemplateTypeParmType>(QT.getTypePtr())->desugar();
441 
442  // Add back the qualifiers.
443  QT = Ctx.getQualifiedType(QT, Quals);
444  }
445 
446  NestedNameSpecifier *Prefix = nullptr;
447  // Local qualifiers are attached to the QualType outside of the
448  // elaborated type. Retrieve them before descending into the
449  // elaborated type.
450  Qualifiers PrefixQualifiers = QT.getLocalQualifiers();
451  QT = QualType(QT.getTypePtr(), 0);
453  if (const auto *ETypeInput = dyn_cast<ElaboratedType>(QT.getTypePtr())) {
454  QT = ETypeInput->getNamedType();
455  assert(!QT.hasLocalQualifiers());
456  Keyword = ETypeInput->getKeyword();
457  }
458  // Create a nested name specifier if needed.
460  true /*FullyQualified*/,
461  WithGlobalNsPrefix);
462 
463  // In case of template specializations iterate over the arguments and
464  // fully qualify them as well.
465  if (isa<const TemplateSpecializationType>(QT.getTypePtr()) ||
466  isa<const RecordType>(QT.getTypePtr())) {
467  // We are asked to fully qualify and we have a Record Type (which
468  // may point to a template specialization) or Template
469  // Specialization Type. We need to fully qualify their arguments.
470 
471  const Type *TypePtr = getFullyQualifiedTemplateType(
472  Ctx, QT.getTypePtr(), WithGlobalNsPrefix);
473  QT = QualType(TypePtr, 0);
474  }
475  if (Prefix || Keyword != ETK_None) {
476  QT = Ctx.getElaboratedType(Keyword, Prefix, QT);
477  }
478  QT = Ctx.getQualifiedType(QT, PrefixQualifiers);
479  return QT;
480 }
481 
483  const ASTContext &Ctx,
484  const PrintingPolicy &Policy,
485  bool WithGlobalNsPrefix) {
486  QualType FQQT = getFullyQualifiedType(QT, Ctx, WithGlobalNsPrefix);
487  return FQQT.getAsString(Policy);
488 }
489 
490 } // end namespace TypeName
491 } // end namespace clang
clang::ElaboratedTypeKeyword
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:5462
clang::NestedNameSpecifier::Create
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
Definition: NestedNameSpecifier.cpp:59
clang::ASTContext::getQualifiedType
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:2126
clang::NestedNameSpecifier::Identifier
@ Identifier
An identifier, stored as an IdentifierInfo*.
Definition: NestedNameSpecifier.h:81
clang::TypeName::getFullyQualifiedTemplateArgument
static bool getFullyQualifiedTemplateArgument(const ASTContext &Ctx, TemplateArgument &Arg, bool WithGlobalNsPrefix)
Definition: QualTypeNames.cpp:94
clang::NestedNameSpecifier::Super
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
Definition: NestedNameSpecifier.h:101
clang::QualType::getLocalQualifiers
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:6578
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1376
llvm::SmallVector
Definition: LLVM.h:38
clang::NestedNameSpecifier::NamespaceAlias
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
Definition: NestedNameSpecifier.h:87
clang::ASTContext::getTemplateSpecializationType
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
Definition: ASTContext.cpp:4881
clang::QualType::getQualifiers
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6586
clang::TypeName::createNestedNameSpecifierForScopeOf
static NestedNameSpecifier * createNestedNameSpecifierForScopeOf(const ASTContext &Ctx, const Decl *decl, bool FullyQualified, bool WithGlobalNsPrefix)
Create a nested name specifier for the declaring context of the type.
Definition: QualTypeNames.cpp:268
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:731
clang::TypeDecl::getTypeForDecl
const Type * getTypeForDecl() const
Definition: Decl.h:3189
clang::TemplateName::getAsTemplateDecl
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
Definition: TemplateName.cpp:108
clang::QualifiedTemplateName::getQualifier
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:433
clang::NestedNameSpecifier
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Definition: NestedNameSpecifier.h:50
clang::Qualifiers
The collection of all-type qualifiers we support.
Definition: Type.h:147
clang::TypeName::createNestedNameSpecifier
static NestedNameSpecifier * createNestedNameSpecifier(const ASTContext &Ctx, const NamespaceDecl *Namesp, bool WithGlobalNsPrefix)
Create a NestedNameSpecifier for Namesp and its enclosing scopes.
Definition: QualTypeNames.cpp:343
clang::UsingShadowDecl
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition: DeclCXX.h:3220
clang::QualType::getAsString
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:1079
clang::TagType
Definition: Type.h:4682
clang::PrintingPolicy
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57
clang::TypeName::createOuterNNS
static NestedNameSpecifier * createOuterNNS(const ASTContext &Ctx, const Decl *D, bool FullyQualify, bool WithGlobalNsPrefix)
Definition: QualTypeNames.cpp:190
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1556
clang::ASTContext::getQualifiedTemplateName
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
Definition: ASTContext.cpp:9067
clang::NestedNameSpecifier::Namespace
@ Namespace
A namespace, stored as a NamespaceDecl*.
Definition: NestedNameSpecifier.h:84
clang::TemplateArgument::getKind
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:244
DeclTemplate.h
clang::TypeName::getFullyQualifiedName
std::string getFullyQualifiedName(QualType QT, const ASTContext &Ctx, const PrintingPolicy &Policy, bool WithGlobalNsPrefix=false)
Get the fully qualified name for a type.
Definition: QualTypeNames.cpp:482
clang::Scope
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:209
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7302
clang::ASTContext::getRValueReferenceType
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
Definition: ASTContext.cpp:3445
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:61
clang::DeclContext::isTranslationUnit
bool isTranslationUnit() const
Definition: DeclBase.h:1977
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:625
clang::TagDecl
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3355
clang::TemplateName::getAsUsingShadowDecl
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
Definition: TemplateName.cpp:171
clang::TypeDecl
Represents a declaration of a type.
Definition: Decl.h:3165
clang::NestedNameSpecifier::Global
@ Global
The global specifier '::'. There is no stored value.
Definition: NestedNameSpecifier.h:97
clang::Type::getAsCXXRecordDecl
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1759
clang::QualifiedTemplateName::hasTemplateKeyword
bool hasTemplateKeyword() const
Whether the template name was prefixed by the "template" keyword.
Definition: TemplateName.h:437
QualTypeNames.h
clang::QualType::getSingleStepDesugaredType
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
Definition: Type.h:1056
clang::NestedNameSpecifier::TypeSpecWithTemplate
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
Definition: NestedNameSpecifier.h:94
clang::ETK_None
@ ETK_None
No keyword precedes the qualified type name.
Definition: Type.h:5483
clang::TemplateName::getAsQualifiedTemplateName
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
Definition: TemplateName.cpp:163
clang::TypeName::getFullyQualifiedNestedNameSpecifier
static NestedNameSpecifier * getFullyQualifiedNestedNameSpecifier(const ASTContext &Ctx, NestedNameSpecifier *scope, bool WithGlobalNsPrefix)
Return a fully qualified version of this name specifier.
Definition: QualTypeNames.cpp:215
clang::DeclContext::getRedeclContext
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1797
clang::ast_matchers::decl
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchersInternal.cpp:734
clang::ClassTemplateDecl
Declaration of a class template.
Definition: DeclTemplate.h:2273
clang::TemplateName
Represents a C++ template name within the type system.
Definition: TemplateName.h:192
clang::TemplateDecl
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:409
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::QualifiedTemplateName
Represents a template name that was expressed as a qualified name.
Definition: TemplateName.h:405
clang::TemplateArgumentList
A template argument list.
Definition: DeclTemplate.h:238
clang::ASTContext::getElaboratedType
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
Definition: ASTContext.cpp:4977
clang::ASTContext::getLValueReferenceType
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
Definition: ASTContext.cpp:3405
DeclarationName.h
clang::DeclaratorContext::TypeName
@ TypeName
clang::TemplateArgument::Type
@ Type
The template argument is a type.
Definition: TemplateBase.h:70
clang
Definition: CalledOnceCheck.h:17
clang::TemplateArgument::Template
@ Template
The template argument is a template name that was provided for a template template parameter.
Definition: TemplateBase.h:86
clang::TemplateArgument::getAsTemplate
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:292
clang::TypeName::getFullyQualifiedTemplateType
static const Type * getFullyQualifiedTemplateType(const ASTContext &Ctx, const Type *TypePtr, bool WithGlobalNsPrefix)
Definition: QualTypeNames.cpp:120
clang::TypeName::getFullyQualifiedType
QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx, bool WithGlobalNsPrefix=false)
Generates a QualType that can be used to name the same type if used at the end of the current transla...
Definition: QualTypeNames.cpp:380
clang::TypeName::getFullyQualifiedTemplateName
static bool getFullyQualifiedTemplateName(const ASTContext &Ctx, TemplateName &TName, bool WithGlobalNsPrefix)
Definition: QualTypeNames.cpp:56
GlobalDecl.h
clang::QualType::getTypePtr
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6559
clang::NestedNameSpecifier::GlobalSpecifier
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.
Definition: NestedNameSpecifier.cpp:126
clang::ASTContext::getPointerType
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
Definition: ASTContext.cpp:3285
clang::NestedNameSpecifier::TypeSpec
@ TypeSpec
A type, stored as a Type*.
Definition: NestedNameSpecifier.h:90
Mangle.h
clang::TemplateArgumentList::size
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:298
clang::NamespaceDecl
Represent a C++ namespace.
Definition: Decl.h:540
clang::QualType::hasLocalQualifiers
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
Definition: Type.h:833
clang::ASTContext::getMemberPointerType
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
Definition: ASTContext.cpp:3483
clang::TemplateArgument::getAsType
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:268
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:441