15 #ifndef LLVM_CLANG_AST_ASTTYPETRAITS_H
16 #define LLVM_CLANG_AST_ASTTYPETRAITS_H
25 #include "llvm/ADT/DenseMapInfo.h"
26 #include "llvm/Support/AlignOf.h"
34 struct PrintingPolicy;
74 return KindId != NKI_None && KindId == Other.KindId;
78 constexpr
bool isNone()
const {
return KindId == NKI_None; }
90 return KindId < Other.KindId;
117 return LHS.KindId == RHS.KindId;
124 return KindId > NKI_LastKindWithoutPointerIdentity;
133 NKI_TemplateArgument,
134 NKI_TemplateArgumentLoc,
137 NKI_NestedNameSpecifierLoc,
139 #define TYPELOC(CLASS, PARENT) NKI_##CLASS##TypeLoc,
140 #include "clang/AST/TypeLocNodes.def"
142 NKI_LastKindWithoutPointerIdentity = NKI_TypeLoc,
143 NKI_CXXBaseSpecifier,
144 NKI_CXXCtorInitializer,
145 NKI_NestedNameSpecifier,
147 #define DECL(DERIVED, BASE) NKI_##DERIVED##Decl,
148 #include "clang/AST/DeclNodes.inc"
150 #define STMT(DERIVED, BASE) NKI_##DERIVED,
151 #include "clang/AST/StmtNodes.inc"
153 #define TYPE(DERIVED, BASE) NKI_##DERIVED##Type,
154 #include "clang/AST/TypeNodes.inc"
156 #define GEN_CLANG_CLAUSE_CLASS
157 #define CLAUSE_CLASS(Enum, Str, Class) NKI_##Class,
158 #include "llvm/Frontend/OpenMP/OMP.inc"
160 #define ATTR(A) NKI_##A##Attr,
161 #include "clang/Basic/AttrList.inc"
167 constexpr
ASTNodeKind(NodeKindId KindId) : KindId(KindId) {}
173 static bool isBaseOf(NodeKindId
Base, NodeKindId Derived,
unsigned *Distance);
178 template <
class T>
struct KindToKindId {
179 static const NodeKindId
Id = NKI_None;
182 struct KindToKindId<const T> : KindToKindId<T> {};
191 static const KindInfo AllKindInfo[NKI_NumberOfKinds];
196 #define KIND_TO_KIND_ID(Class) \
197 template <> struct ASTNodeKind::KindToKindId<Class> { \
198 static const NodeKindId Id = NKI_##Class; \
208 #define TYPELOC(CLASS, PARENT) KIND_TO_KIND_ID(CLASS##TypeLoc)
209 #include "clang/AST/TypeLocNodes.def"
218 #define DECL(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Decl)
219 #include "clang/AST/DeclNodes.inc"
220 #define STMT(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED)
221 #include "clang/AST/StmtNodes.inc"
222 #define TYPE(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Type)
223 #include "clang/AST/TypeNodes.inc"
224 #define GEN_CLANG_CLAUSE_CLASS
225 #define CLAUSE_CLASS(Enum, Str, Class) KIND_TO_KIND_ID(Class)
226 #include "llvm/Frontend/OpenMP/OMP.inc"
227 #define ATTR(A) KIND_TO_KIND_ID(A##Attr)
228 #include "clang/Basic/AttrList.inc"
229 #undef KIND_TO_KIND_ID
251 template <
typename T>
268 template <
typename T>
const T *
get()
const {
269 return BaseConverter<T>::get(NodeKind, &Storage);
275 template <
typename T>
277 return BaseConverter<T>::getUnchecked(NodeKind, &Storage);
289 ? *
reinterpret_cast<void *
const *
>(&Storage)
297 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
310 if (!NodeKind.
isSame(Other.NodeKind))
311 return NodeKind < Other.NodeKind;
313 if (ASTNodeKind::getFromNodeKind<QualType>().isSame(NodeKind))
314 return getUnchecked<QualType>().getAsOpaquePtr() <
315 Other.getUnchecked<
QualType>().getAsOpaquePtr();
317 if (ASTNodeKind::getFromNodeKind<TypeLoc>().isBaseOf(NodeKind)) {
318 auto TLA = getUnchecked<TypeLoc>();
319 auto TLB = Other.getUnchecked<
TypeLoc>();
320 return std::make_pair(TLA.getType().getAsOpaquePtr(),
321 TLA.getOpaqueData()) <
322 std::make_pair(TLB.getType().getAsOpaquePtr(),
323 TLB.getOpaqueData());
326 if (ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>().isSame(
328 auto NNSLA = getUnchecked<NestedNameSpecifierLoc>();
330 return std::make_pair(NNSLA.getNestedNameSpecifier(),
331 NNSLA.getOpaqueData()) <
332 std::make_pair(NNSLB.getNestedNameSpecifier(),
333 NNSLB.getOpaqueData());
342 if (!NodeKind.
isSame(Other.NodeKind))
346 if (ASTNodeKind::getFromNodeKind<QualType>().isSame(NodeKind))
347 return getUnchecked<QualType>() == Other.getUnchecked<
QualType>();
349 if (ASTNodeKind::getFromNodeKind<TypeLoc>().isBaseOf(NodeKind))
350 return getUnchecked<TypeLoc>() == Other.getUnchecked<
TypeLoc>();
352 if (ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>().isSame(NodeKind))
353 return getUnchecked<NestedNameSpecifierLoc>() ==
378 if (ASTNodeKind::getFromNodeKind<TypeLoc>().isBaseOf(Val.NodeKind)) {
384 if (ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>().isSame(
388 NNSL.getOpaqueData());
407 template <
typename T,
typename EnablerT =
void>
struct BaseConverter;
410 template <
typename T,
typename BaseT>
struct DynCastPtrConverter {
412 if (ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind))
416 static const T &
getUnchecked(ASTNodeKind NodeKind,
const void *Storage) {
417 assert(ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind));
418 return *cast<T>(
static_cast<const BaseT *
>(
419 *
reinterpret_cast<const void *
const *
>(Storage)));
424 new (&Result.Storage)
const void *(&
Node);
430 template <
typename T>
struct PtrConverter {
431 static const T *
get(ASTNodeKind NodeKind,
const void *Storage) {
432 if (ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind))
436 static const T &
getUnchecked(ASTNodeKind NodeKind,
const void *Storage) {
437 assert(ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind));
438 return *
static_cast<const T *
>(
439 *
reinterpret_cast<const void *
const *
>(Storage));
443 Result.NodeKind = ASTNodeKind::getFromNodeKind<T>();
444 new (&Result.Storage)
const void *(&
Node);
450 template <
typename T>
struct ValueConverter {
451 static const T *
get(ASTNodeKind NodeKind,
const void *Storage) {
452 if (ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind))
453 return reinterpret_cast<const T *
>(Storage);
456 static const T &
getUnchecked(ASTNodeKind NodeKind,
const void *Storage) {
457 assert(ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind));
458 return *
reinterpret_cast<const T *
>(Storage);
462 Result.NodeKind = ASTNodeKind::getFromNodeKind<T>();
463 new (&Result.Storage) T(
Node);
471 template <
typename T,
typename BaseT,
472 typename = std::enable_if_t<(
sizeof(T) ==
sizeof(BaseT))>>
473 struct DynCastValueConverter {
474 static const T *
get(ASTNodeKind NodeKind,
const void *Storage) {
475 if (ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind))
479 static const T &
getUnchecked(ASTNodeKind NodeKind,
const void *Storage) {
480 assert(ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind));
481 return *
static_cast<const T *
>(
reinterpret_cast<const BaseT *
>(Storage));
486 new (&Result.Storage) T(
Node);
501 llvm::AlignedCharArrayUnion<
const void *, TemplateArgument,
502 TemplateArgumentLoc, NestedNameSpecifierLoc,
503 QualType, TypeLoc, ObjCProtocolLoc>
507 template <
typename T>
508 struct DynTypedNode::BaseConverter<
509 T, std::enable_if_t<std::is_base_of<Decl, T>::value>>
510 :
public DynCastPtrConverter<T, Decl> {};
512 template <
typename T>
513 struct DynTypedNode::BaseConverter<
514 T,
std::enable_if_t<std::is_base_of<Stmt, T>::value>>
515 :
public DynCastPtrConverter<T, Stmt> {};
517 template <
typename T>
518 struct DynTypedNode::BaseConverter<
519 T,
std::enable_if_t<std::is_base_of<Type, T>::value>>
520 :
public DynCastPtrConverter<T, Type> {};
522 template <
typename T>
523 struct DynTypedNode::BaseConverter<
524 T,
std::enable_if_t<std::is_base_of<OMPClause, T>::value>>
525 :
public DynCastPtrConverter<T, OMPClause> {};
527 template <
typename T>
528 struct DynTypedNode::BaseConverter<
529 T,
std::enable_if_t<std::is_base_of<Attr, T>::value>>
530 :
public DynCastPtrConverter<T, Attr> {};
533 struct DynTypedNode::BaseConverter<
537 struct DynTypedNode::BaseConverter<
541 struct DynTypedNode::BaseConverter<
546 :
public ValueConverter<TemplateArgumentLoc> {};
550 :
public ValueConverter<LambdaCapture> {};
553 struct DynTypedNode::BaseConverter<
554 TemplateName, void> :
public ValueConverter<TemplateName> {};
557 struct DynTypedNode::BaseConverter<
559 void> :
public ValueConverter<NestedNameSpecifierLoc> {};
563 void> :
public ValueConverter<QualType> {};
565 template <
typename T>
566 struct DynTypedNode::BaseConverter<
567 T,
std::enable_if_t<std::is_base_of<TypeLoc, T>::value>>
568 :
public DynCastValueConverter<T, TypeLoc> {};
572 :
public PtrConverter<CXXBaseSpecifier> {};
576 :
public ValueConverter<ObjCProtocolLoc> {};
582 template <
typename T,
typename EnablerT>
struct DynTypedNode::BaseConverter {