clang 24.0.0git
ASTTypeTraits.h
Go to the documentation of this file.
1//===--- ASTTypeTraits.h ----------------------------------------*- C++ -*-===//
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//
9// Provides a dynamic type identifier and a dynamically typed node container
10// that can be used to store an AST base node at runtime in the same storage in
11// a type safe way.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_AST_ASTTYPETRAITS_H
16#define LLVM_CLANG_AST_ASTTYPETRAITS_H
17
18#include "clang/AST/ASTFwd.h"
19#include "clang/AST/DeclCXX.h"
23#include "clang/AST/TypeLoc.h"
24#include "clang/Basic/LLVM.h"
25#include "llvm/ADT/DenseMapInfo.h"
26#include "llvm/Support/AlignOf.h"
27
28namespace llvm {
29class raw_ostream;
30} // namespace llvm
31
32namespace clang {
33
34struct PrintingPolicy;
35
36/// Defines how we descend a level in the AST when we pass
37/// through expressions.
39 /// Will traverse all child nodes.
41
42 /// Ignore AST nodes not written in the source
44};
45
46/// Kind identifier.
47///
48/// It can be constructed from any node kind and allows for runtime type
49/// hierarchy checks.
50/// Use getFromNodeKind<T>() to construct them.
52public:
53 /// Empty identifier. It matches nothing.
54 constexpr ASTNodeKind() : KindId(NKI_None) {}
55
56 /// Construct an identifier for T.
57 template <class T> static constexpr ASTNodeKind getFromNodeKind() {
58 return ASTNodeKind(KindToKindId<T>::Id);
59 }
60
61 /// \{
62 /// Construct an identifier for the dynamic type of the node
63 static ASTNodeKind getFromNode(const Decl &D);
64 static ASTNodeKind getFromNode(const Stmt &S);
65 static ASTNodeKind getFromNode(const Type &T);
66 static ASTNodeKind getFromNode(const TypeLoc &T);
68 static ASTNodeKind getFromNode(const OMPClause &C);
69 static ASTNodeKind getFromNode(const Attr &A);
70 /// \}
71
72 /// Returns \c true if \c this and \c Other represent the same kind.
73 constexpr bool isSame(ASTNodeKind Other) const {
74 return KindId != NKI_None && KindId == Other.KindId;
75 }
76
77 /// Returns \c true only for the default \c ASTNodeKind()
78 constexpr bool isNone() const { return KindId == NKI_None; }
79
80 /// Returns \c true if \c this is a base kind of (or same as) \c Other.
81 bool isBaseOf(ASTNodeKind Other) const;
82
83 /// Returns \c true if \c this is a base kind of (or same as) \c Other.
84 /// \param Distance If non-null, used to return the distance between \c this
85 /// and \c Other in the class hierarchy.
86 bool isBaseOf(ASTNodeKind Other, unsigned *Distance) const;
87
88 /// String representation of the kind.
89 StringRef asStringRef() const;
90
91 /// Strict weak ordering for ASTNodeKind.
92 constexpr bool operator<(const ASTNodeKind &Other) const {
93 return KindId < Other.KindId;
94 }
95
96 /// Return the most derived type between \p Kind1 and \p Kind2.
97 ///
98 /// Return ASTNodeKind() if they are not related.
100
101 /// Return the most derived common ancestor between Kind1 and Kind2.
102 ///
103 /// Return ASTNodeKind() if they are not related.
105 ASTNodeKind Kind2);
106
108
109 /// Hooks for using ASTNodeKind as a key in a DenseMap.
111 // ASTNodeKind() is a good empty key because it is represented as a 0.
112 static unsigned getHashValue(const ASTNodeKind &Val) { return Val.KindId; }
113 static bool isEqual(const ASTNodeKind &LHS, const ASTNodeKind &RHS) {
114 return LHS.KindId == RHS.KindId;
115 }
116 };
117
118 /// Check if the given ASTNodeKind identifies a type that offers pointer
119 /// identity. This is useful for the fast path in DynTypedNode.
120 constexpr bool hasPointerIdentity() const {
121 return KindId > NKI_LastKindWithoutPointerIdentity;
122 }
123
124private:
125 /// Kind ids.
126 ///
127 /// Includes all possible base and derived kinds.
128 enum NodeKindId {
129 NKI_None,
130 NKI_TemplateArgument,
131 NKI_TemplateArgumentLoc,
132 NKI_LambdaCapture,
133 NKI_TemplateName,
134 NKI_NestedNameSpecifier,
135 NKI_NestedNameSpecifierLoc,
136 NKI_ObjCProtocolLoc,
137 NKI_QualType,
138#define TYPELOC(CLASS, PARENT) NKI_##CLASS##TypeLoc,
139#include "clang/AST/TypeLocNodes.def"
140 NKI_TypeLoc,
141 NKI_LastKindWithoutPointerIdentity = NKI_TypeLoc,
142 NKI_CXXBaseSpecifier,
143 NKI_CXXCtorInitializer,
144 NKI_Decl,
145#define DECL(DERIVED, BASE) NKI_##DERIVED##Decl,
146#include "clang/AST/DeclNodes.inc"
147 NKI_Stmt,
148#define STMT(DERIVED, BASE) NKI_##DERIVED,
149#include "clang/AST/StmtNodes.inc"
150 NKI_Type,
151#define TYPE(DERIVED, BASE) NKI_##DERIVED##Type,
152#include "clang/AST/TypeNodes.inc"
153 NKI_OMPClause,
154#define GEN_CLANG_CLAUSE_CLASS
155#define CLAUSE_CLASS(Enum, Str, Class) NKI_##Class,
156#include "llvm/Frontend/OpenMP/OMP.inc"
157 NKI_Attr,
158#define ATTR(A) NKI_##A##Attr,
159#include "clang/Basic/AttrList.inc"
160 NKI_ConceptReference,
161 NKI_OffsetOfNode,
162 NKI_NumberOfKinds
163 };
164
165 /// Use getFromNodeKind<T>() to construct the kind.
166 constexpr ASTNodeKind(NodeKindId KindId) : KindId(KindId) {}
167
168 /// Returns \c true if \c Base is a base kind of (or same as) \c
169 /// Derived.
170 static bool isBaseOf(NodeKindId Base, NodeKindId Derived);
171
172 /// Returns \c true if \c Base is a base kind of (or same as) \c
173 /// Derived.
174 /// \param Distance If non-null, used to return the distance between \c Base
175 /// and \c Derived in the class hierarchy.
176 static bool isBaseOf(NodeKindId Base, NodeKindId Derived, unsigned *Distance);
177
178 /// Helper meta-function to convert a kind T to its enum value.
179 ///
180 /// This struct is specialized below for all known kinds.
181 template <class T> struct KindToKindId {
182 static const NodeKindId Id = NKI_None;
183 };
184 template <class T>
185 struct KindToKindId<const T> : KindToKindId<T> {};
186
187 /// Per kind info.
188 struct KindInfo {
189 /// The id of the parent kind, or None if it has no parent.
190 NodeKindId ParentId;
191 /// Name of the kind.
192 const char *Name;
193 };
194 static const KindInfo AllKindInfo[NKI_NumberOfKinds];
195
196 NodeKindId KindId;
197};
198
199#define KIND_TO_KIND_ID(Class) \
200 template <> struct ASTNodeKind::KindToKindId<Class> { \
201 static const NodeKindId Id = NKI_##Class; \
202 };
203KIND_TO_KIND_ID(CXXCtorInitializer)
204KIND_TO_KIND_ID(TemplateArgument)
205KIND_TO_KIND_ID(TemplateArgumentLoc)
206KIND_TO_KIND_ID(LambdaCapture)
208KIND_TO_KIND_ID(NestedNameSpecifier)
209KIND_TO_KIND_ID(NestedNameSpecifierLoc)
210KIND_TO_KIND_ID(QualType)
211#define TYPELOC(CLASS, PARENT) KIND_TO_KIND_ID(CLASS##TypeLoc)
212#include "clang/AST/TypeLocNodes.def"
213KIND_TO_KIND_ID(TypeLoc)
214KIND_TO_KIND_ID(Decl)
215KIND_TO_KIND_ID(Stmt)
216KIND_TO_KIND_ID(Type)
218KIND_TO_KIND_ID(Attr)
219KIND_TO_KIND_ID(ObjCProtocolLoc)
220KIND_TO_KIND_ID(CXXBaseSpecifier)
221KIND_TO_KIND_ID(ConceptReference)
222KIND_TO_KIND_ID(OffsetOfNode)
223#define DECL(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Decl)
224#include "clang/AST/DeclNodes.inc"
225#define STMT(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED)
226#include "clang/AST/StmtNodes.inc"
227#define TYPE(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Type)
228#include "clang/AST/TypeNodes.inc"
229#define GEN_CLANG_CLAUSE_CLASS
230#define CLAUSE_CLASS(Enum, Str, Class) KIND_TO_KIND_ID(Class)
231#include "llvm/Frontend/OpenMP/OMP.inc"
232#define ATTR(A) KIND_TO_KIND_ID(A##Attr)
233#include "clang/Basic/AttrList.inc"
234#undef KIND_TO_KIND_ID
235
236inline raw_ostream &operator<<(raw_ostream &OS, ASTNodeKind K) {
237 OS << K.asStringRef();
238 return OS;
239}
240
241/// A dynamically typed AST node container.
242///
243/// Stores an AST node in a type safe way. This allows writing code that
244/// works with different kinds of AST nodes, despite the fact that they don't
245/// have a common base class.
246///
247/// Use \c create(Node) to create a \c DynTypedNode from an AST node,
248/// and \c get<T>() to retrieve the node as type T if the types match.
249///
250/// See \c ASTNodeKind for which node base types are currently supported;
251/// You can create DynTypedNodes for all nodes in the inheritance hierarchy of
252/// the supported base types.
254public:
255 /// Creates a \c DynTypedNode from \c Node.
256 template <typename T> static DynTypedNode create(const T &Node) {
257 using Converter = BaseConverter<T>;
258 static_assert(
259 Converter::StoresPointer ==
262 "hasPointerIdentity() must agree with whether DynTypedNode "
263 "stores a node by pointer");
264 return Converter::create(Node);
265 }
266
267 /// Retrieve the stored node as type \c T.
268 ///
269 /// Returns NULL if the stored node does not have a type that is
270 /// convertible to \c T.
271 ///
272 /// For types that have identity via their pointer in the AST
273 /// (like \c Stmt, \c Decl and \c Type) the returned
274 /// pointer points to the referenced AST node.
275 /// For other types (like \c QualType) the value is stored directly
276 /// in the \c DynTypedNode, and the returned pointer points at
277 /// the storage inside DynTypedNode. For those nodes, do not
278 /// use the pointer outside the scope of the DynTypedNode.
279 template <typename T> const T *get() const {
280 return BaseConverter<T>::get(NodeKind, &Storage);
281 }
282
283 /// Retrieve the stored node as type \c T.
284 ///
285 /// Similar to \c get(), but asserts that the type is what we are expecting.
286 template <typename T>
287 const T &getUnchecked() const {
288 return BaseConverter<T>::getUnchecked(NodeKind, &Storage);
289 }
290
291 ASTNodeKind getNodeKind() const { return NodeKind; }
292
293 /// Returns a pointer that identifies the stored AST node.
294 ///
295 /// Note that this is not supported by all AST nodes. For AST nodes
296 /// that don't have a pointer-defined identity inside the AST, this
297 /// method returns NULL.
298 const void *getMemoizationData() const {
299 return NodeKind.hasPointerIdentity()
300 ? *reinterpret_cast<void *const *>(&Storage)
301 : nullptr;
302 }
303
304 /// Prints the node to the given output stream.
305 void print(llvm::raw_ostream &OS, const PrintingPolicy &PP) const;
306
307 /// Dumps the node to the given output stream.
308 void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
309
310 /// For nodes which represent textual entities in the source code,
311 /// return their SourceRange. For all other nodes, return SourceRange().
312 SourceRange getSourceRange(bool IncludeQualifier = false) const;
313
314 /// @{
315 /// Imposes an order on \c DynTypedNode.
316 ///
317 /// FIXME: Implement comparison for TemplateName, LambdaCapture,
318 /// TemplateArgument, and TemplateArgumentLoc.
319 bool operator<(const DynTypedNode &Other) const {
320 if (!NodeKind.isSame(Other.NodeKind))
321 return NodeKind < Other.NodeKind;
322
323 if (ASTNodeKind::getFromNodeKind<QualType>().isSame(NodeKind))
324 return getUnchecked<QualType>().getAsOpaquePtr() <
325 Other.getUnchecked<QualType>().getAsOpaquePtr();
326
327 if (ASTNodeKind::getFromNodeKind<TypeLoc>().isBaseOf(NodeKind)) {
328 auto TLA = getUnchecked<TypeLoc>();
329 auto TLB = Other.getUnchecked<TypeLoc>();
330 return std::make_pair(TLA.getType().getAsOpaquePtr(),
331 TLA.getOpaqueData()) <
332 std::make_pair(TLB.getType().getAsOpaquePtr(),
333 TLB.getOpaqueData());
334 }
335
337 NodeKind)) {
339 auto NNSLB = Other.getUnchecked<NestedNameSpecifierLoc>();
340 return std::make_pair(NNSLA.getNestedNameSpecifier().getAsVoidPointer(),
341 NNSLA.getOpaqueData()) <
342 std::make_pair(NNSLB.getNestedNameSpecifier().getAsVoidPointer(),
343 NNSLB.getOpaqueData());
344 }
345
347 return getUnchecked<NestedNameSpecifier>().getAsVoidPointer() <
348 Other.getUnchecked<NestedNameSpecifier>().getAsVoidPointer();
349
350 if (ASTNodeKind::getFromNodeKind<ObjCProtocolLoc>().isSame(NodeKind)) {
352 auto PLB = Other.getUnchecked<ObjCProtocolLoc>();
353 return std::make_pair(PLA.getProtocol(), PLA.getLocation()) <
354 std::make_pair(PLB.getProtocol(), PLB.getLocation());
355 }
356
357 assert(getMemoizationData() && Other.getMemoizationData());
358 return getMemoizationData() < Other.getMemoizationData();
359 }
360 bool operator==(const DynTypedNode &Other) const {
361 // DynTypedNode::create() stores the exact kind of the node in NodeKind.
362 // If they contain the same node, their NodeKind must be the same.
363 if (!NodeKind.isSame(Other.NodeKind))
364 return false;
365
366 // FIXME: Implement for other types.
367 if (ASTNodeKind::getFromNodeKind<QualType>().isSame(NodeKind))
368 return getUnchecked<QualType>() == Other.getUnchecked<QualType>();
369
370 if (ASTNodeKind::getFromNodeKind<TypeLoc>().isBaseOf(NodeKind))
371 return getUnchecked<TypeLoc>() == Other.getUnchecked<TypeLoc>();
372
375 Other.getUnchecked<NestedNameSpecifierLoc>();
376
379 Other.getUnchecked<NestedNameSpecifier>();
380
381 if (ASTNodeKind::getFromNodeKind<ObjCProtocolLoc>().isSame(NodeKind)) {
383 auto PLB = Other.getUnchecked<ObjCProtocolLoc>();
384 return PLA.getProtocol() == PLB.getProtocol() &&
385 PLA.getLocation() == PLB.getLocation();
386 }
387
388 assert(getMemoizationData() && Other.getMemoizationData());
389 return getMemoizationData() == Other.getMemoizationData();
390 }
391 bool operator!=(const DynTypedNode &Other) const {
392 return !operator==(Other);
393 }
394 /// @}
395
396 /// Hooks for using DynTypedNode as a key in a DenseMap.
398 static unsigned getHashValue(const DynTypedNode &Val) {
399 // FIXME: Add hashing support for the remaining types.
400 if (ASTNodeKind::getFromNodeKind<TypeLoc>().isBaseOf(Val.NodeKind)) {
401 auto TL = Val.getUnchecked<TypeLoc>();
402 return llvm::hash_combine(TL.getType().getAsOpaquePtr(),
403 TL.getOpaqueData());
404 }
405
407 Val.NodeKind)) {
408 auto NNSL = Val.getUnchecked<NestedNameSpecifierLoc>();
409 return llvm::hash_combine(
410 NNSL.getNestedNameSpecifier().getAsVoidPointer(),
411 NNSL.getOpaqueData());
412 }
413
415 Val.NodeKind))
416 return llvm::DenseMapInfo<NestedNameSpecifier>::getHashValue(
418
420 Val.NodeKind)) {
421 auto PL = Val.getUnchecked<ObjCProtocolLoc>();
422 return llvm::hash_combine(PL.getProtocol(),
423 PL.getLocation().getRawEncoding());
424 }
425
426 assert(Val.getMemoizationData());
428 }
429 static bool isEqual(const DynTypedNode &LHS, const DynTypedNode &RHS) {
430 return LHS == RHS;
431 }
432 };
433
434private:
435 /// Takes care of converting from and to \c T.
436 template <typename T, typename EnablerT = void> struct BaseConverter;
437
438 /// Converter that uses dyn_cast<T> from a stored BaseT*.
439 template <typename T, typename BaseT> struct DynCastPtrConverter {
440 static constexpr bool StoresPointer = true;
441 using BaseType = BaseT;
442 static const T *get(ASTNodeKind NodeKind, const void *Storage) {
443 if (ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind))
444 return &getUnchecked(NodeKind, Storage);
445 return nullptr;
446 }
447 static const T &getUnchecked(ASTNodeKind NodeKind, const void *Storage) {
448 assert(ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind));
449 return *cast<T>(static_cast<const BaseT *>(
450 *reinterpret_cast<const void *const *>(Storage)));
451 }
452 static DynTypedNode create(const BaseT &Node) {
454 Result.NodeKind = ASTNodeKind::getFromNode(Node);
455 new (&Result.Storage) const void *(&Node);
456 return Result;
457 }
458 };
459
460 /// Converter that stores T* (by pointer).
461 template <typename T> struct PtrConverter {
462 static constexpr bool StoresPointer = true;
463 using BaseType = T;
464 static const T *get(ASTNodeKind NodeKind, const void *Storage) {
465 if (ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind))
466 return &getUnchecked(NodeKind, Storage);
467 return nullptr;
468 }
469 static const T &getUnchecked(ASTNodeKind NodeKind, const void *Storage) {
470 assert(ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind));
471 return *static_cast<const T *>(
472 *reinterpret_cast<const void *const *>(Storage));
473 }
474 static DynTypedNode create(const T &Node) {
477 new (&Result.Storage) const void *(&Node);
478 return Result;
479 }
480 };
481
482 /// Converter that stores T (by value).
483 template <typename T> struct ValueConverter {
484 static constexpr bool StoresPointer = false;
485 using BaseType = T;
486 static const T *get(ASTNodeKind NodeKind, const void *Storage) {
487 if (ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind))
488 return reinterpret_cast<const T *>(Storage);
489 return nullptr;
490 }
491 static const T &getUnchecked(ASTNodeKind NodeKind, const void *Storage) {
492 assert(ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind));
493 return *reinterpret_cast<const T *>(Storage);
494 }
495 static DynTypedNode create(const T &Node) {
498 new (&Result.Storage) T(Node);
499 return Result;
500 }
501 };
502
503 /// Converter that stores nodes by value. It must be possible to dynamically
504 /// cast the stored node within a type hierarchy without breaking (especially
505 /// through slicing).
506 template <typename T, typename BaseT,
507 typename = std::enable_if_t<(sizeof(T) == sizeof(BaseT))>>
508 struct DynCastValueConverter {
509 static constexpr bool StoresPointer = false;
510 using BaseType = BaseT;
511 static const T *get(ASTNodeKind NodeKind, const void *Storage) {
512 if (ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind))
513 return &getUnchecked(NodeKind, Storage);
514 return nullptr;
515 }
516 static const T &getUnchecked(ASTNodeKind NodeKind, const void *Storage) {
517 assert(ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind));
518 return *static_cast<const T *>(reinterpret_cast<const BaseT *>(Storage));
519 }
520 static DynTypedNode create(const T &Node) {
522 Result.NodeKind = ASTNodeKind::getFromNode(Node);
523 new (&Result.Storage) T(Node);
524 return Result;
525 }
526 };
527
528 ASTNodeKind NodeKind;
529
530 /// Stores the data of the node.
531 ///
532 /// Note that we can store \c Decls, \c Stmts, \c Types and
533 /// \c CXXCtorInitializer by pointer as they are guaranteed to be unique
534 /// pointers pointing to dedicated storage in the AST.
535 /// \c QualTypes, \c NestedNameSpecifiers, \c NestedNameSpecifierLocs,
536 /// \c TypeLocs, \c TemplateArguments and \c TemplateArgumentLocs on the other
537 /// hand do not have storage or unique pointers and thus need to be stored by
538 /// value.
539 llvm::AlignedCharArrayUnion<
540 const void *, TemplateArgument, TemplateArgumentLoc, NestedNameSpecifier,
541 NestedNameSpecifierLoc, QualType, TypeLoc, ObjCProtocolLoc>
542 Storage;
543};
544
545template <typename T>
546struct DynTypedNode::BaseConverter<
547 T, std::enable_if_t<std::is_base_of<Decl, T>::value>>
548 : public DynCastPtrConverter<T, Decl> {};
549
550template <typename T>
551struct DynTypedNode::BaseConverter<
552 T, std::enable_if_t<std::is_base_of<Stmt, T>::value>>
553 : public DynCastPtrConverter<T, Stmt> {};
554
555template <typename T>
556struct DynTypedNode::BaseConverter<
557 T, std::enable_if_t<std::is_base_of<Type, T>::value>>
558 : public DynCastPtrConverter<T, Type> {};
559
560template <typename T>
561struct DynTypedNode::BaseConverter<
562 T, std::enable_if_t<std::is_base_of<OMPClause, T>::value>>
563 : public DynCastPtrConverter<T, OMPClause> {};
564
565template <typename T>
566struct DynTypedNode::BaseConverter<
567 T, std::enable_if_t<std::is_base_of<Attr, T>::value>>
568 : public DynCastPtrConverter<T, Attr> {};
569
570template <>
571struct DynTypedNode::BaseConverter<NestedNameSpecifier, void>
572 : public ValueConverter<NestedNameSpecifier> {};
573
574template <>
575struct DynTypedNode::BaseConverter<
576 CXXCtorInitializer, void> : public PtrConverter<CXXCtorInitializer> {};
577
578template <>
579struct DynTypedNode::BaseConverter<
580 TemplateArgument, void> : public ValueConverter<TemplateArgument> {};
581
582template <>
583struct DynTypedNode::BaseConverter<TemplateArgumentLoc, void>
584 : public ValueConverter<TemplateArgumentLoc> {};
585
586template <>
587struct DynTypedNode::BaseConverter<LambdaCapture, void>
588 : public ValueConverter<LambdaCapture> {};
589
590template <>
591struct DynTypedNode::BaseConverter<
592 TemplateName, void> : public ValueConverter<TemplateName> {};
593
594template <>
595struct DynTypedNode::BaseConverter<
597 void> : public ValueConverter<NestedNameSpecifierLoc> {};
598
599template <>
600struct DynTypedNode::BaseConverter<QualType,
601 void> : public ValueConverter<QualType> {};
602
603template <typename T>
604struct DynTypedNode::BaseConverter<
605 T, std::enable_if_t<std::is_base_of<TypeLoc, T>::value>>
606 : public DynCastValueConverter<T, TypeLoc> {};
607
608template <>
609struct DynTypedNode::BaseConverter<CXXBaseSpecifier, void>
610 : public PtrConverter<CXXBaseSpecifier> {};
611
612template <>
613struct DynTypedNode::BaseConverter<ObjCProtocolLoc, void>
614 : public ValueConverter<ObjCProtocolLoc> {};
615
616template <>
617struct DynTypedNode::BaseConverter<ConceptReference, void>
618 : public PtrConverter<ConceptReference> {};
619
620template <>
621struct DynTypedNode::BaseConverter<OffsetOfNode, void>
622 : public PtrConverter<OffsetOfNode> {};
623
624// The only operation we allow on unsupported types is \c get.
625// This allows to conveniently use \c DynTypedNode when having an arbitrary
626// AST node that is not supported, but prevents misuse - a user cannot create
627// a DynTypedNode from arbitrary types.
628template <typename T, typename EnablerT> struct DynTypedNode::BaseConverter {
629 static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
630 return NULL;
631 }
632};
633
634} // end namespace clang
635
636namespace llvm {
637
638template <>
639struct DenseMapInfo<clang::ASTNodeKind> : clang::ASTNodeKind::DenseMapInfo {};
640
641template <>
642struct DenseMapInfo<clang::DynTypedNode> : clang::DynTypedNode::DenseMapInfo {};
643
644} // end namespace llvm
645
646#endif
Forward declaration of all AST node types.
#define KIND_TO_KIND_ID(Class)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the LambdaCapture class.
Defines the clang::TypeLoc interface and its subclasses.
#define NULL
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:245
Kind identifier.
static ASTNodeKind getFromNode(const LambdaCapture &L)
StringRef asStringRef() const
String representation of the kind.
bool isBaseOf(ASTNodeKind Other) const
Returns true if this is a base kind of (or same as) Other.
constexpr ASTNodeKind()
Empty identifier. It matches nothing.
ASTNodeKind getCladeKind() const
constexpr bool hasPointerIdentity() const
Check if the given ASTNodeKind identifies a type that offers pointer identity.
constexpr bool operator<(const ASTNodeKind &Other) const
Strict weak ordering for ASTNodeKind.
static ASTNodeKind getMostDerivedCommonAncestor(ASTNodeKind Kind1, ASTNodeKind Kind2)
Return the most derived common ancestor between Kind1 and Kind2.
static ASTNodeKind getMostDerivedType(ASTNodeKind Kind1, ASTNodeKind Kind2)
Return the most derived type between Kind1 and Kind2.
static ASTNodeKind getFromNode(const Decl &D)
constexpr bool isSame(ASTNodeKind Other) const
Returns true if this and Other represent the same kind.
constexpr bool isNone() const
Returns true only for the default ASTNodeKind()
static constexpr ASTNodeKind getFromNodeKind()
Construct an identifier for T.
Attr - This represents one attribute.
Definition Attr.h:47
Represents a base class of a C++ class.
Definition DeclCXX.h:146
Represents a C++ base or member initializer.
Definition DeclCXX.h:2410
A reference to a concept and its template args, as it appears in the code.
Definition ASTConcept.h:127
Decl - This represents one declaration (or definition), e.g.
Definition DeclBase.h:86
SourceLocation getLocation() const
Definition DeclBase.h:448
A dynamically typed AST node container.
bool operator<(const DynTypedNode &Other) const
ASTNodeKind getNodeKind() const
bool operator==(const DynTypedNode &Other) const
bool operator!=(const DynTypedNode &Other) const
const T * get() const
Retrieve the stored node as type T.
const T & getUnchecked() const
Retrieve the stored node as type T.
static DynTypedNode create(const T &Node)
Creates a DynTypedNode from Node.
const void * getMemoizationData() const
Returns a pointer that identifies the stored AST node.
void dump(llvm::raw_ostream &OS, const ASTContext &Context) const
Dumps the node to the given output stream.
SourceRange getSourceRange(bool IncludeQualifier=false) const
For nodes which represent textual entities in the source code, return their SourceRange.
void print(llvm::raw_ostream &OS, const PrintingPolicy &PP) const
Prints the node to the given output stream.
Describes the capture of a variable or of this, or of a C++1y init-capture.
A C++ nested-name-specifier augmented with source location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
This is a basic class for representing single OpenMP clause.
ObjCProtocolDecl * getProtocol() const
Definition TypeLoc.h:2821
Helper class for OffsetOfExpr.
Definition Expr.h:2490
A (possibly-)qualified type.
Definition TypeBase.h:938
A trivial tuple used to represent a source range.
Stmt - This represents one statement.
Definition Stmt.h:85
Location wrapper for a TemplateArgument.
Represents a template argument.
Represents a C++ template name within the type system.
Base wrapper for a particular "section" of type source info.
Definition TypeLoc.h:59
The base class of the type hierarchy.
Definition TypeBase.h:1879
DynTypedNode DynTypedNode
Top level wrappers for InstallAPI frontend operations.
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
Definition Parser.h:61
TraversalKind
Defines how we descend a level in the AST when we pass through expressions.
@ TK_AsIs
Will traverse all child nodes.
@ TK_IgnoreUnlessSpelledInSource
Ignore AST nodes not written in the source.
@ Result
The result type of a method or function.
Definition TypeBase.h:906
const FunctionProtoType * T
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ConceptReference *C)
Insertion operator for diagnostics.
U cast(CodeGen::Address addr)
Definition Address.h:327
Diagnostic wrappers for TextAPI types for error reporting.
Definition Dominators.h:30
hash_code hash_value(const clang::dependencies::ModuleID &ID)
Hooks for using ASTNodeKind as a key in a DenseMap.
static unsigned getHashValue(const ASTNodeKind &Val)
static bool isEqual(const ASTNodeKind &LHS, const ASTNodeKind &RHS)
Hooks for using DynTypedNode as a key in a DenseMap.
static unsigned getHashValue(const DynTypedNode &Val)
static bool isEqual(const DynTypedNode &LHS, const DynTypedNode &RHS)
Describes how types, statements, expressions, and declarations should be printed.