granicus.if.org Git - clang/blob - include/clang/AST/ASTTypeTraits.h

   1 //===--- ASTTypeTraits.h ----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  Provides a dynamic type identifier and a dynamically typed node container
  11 //  that can be used to store an AST base node at runtime in the same storage in
  12 //  a type safe way.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_CLANG_AST_AST_TYPE_TRAITS_H
  17 #define LLVM_CLANG_AST_AST_TYPE_TRAITS_H
  18
  19 #include "clang/AST/ASTFwd.h"
  20 #include "clang/AST/Decl.h"
  21 #include "clang/AST/NestedNameSpecifier.h"
  22 #include "clang/AST/Stmt.h"
  23 #include "clang/AST/TemplateBase.h"
  24 #include "clang/AST/TypeLoc.h"
  25 #include "clang/Basic/LLVM.h"
  26 #include "llvm/Support/AlignOf.h"
  27
  28 namespace clang {
  29 namespace ast_type_traits {
  30
  31 /// \brief Kind identifier.
  32 ///
  33 /// It can be constructed from any node kind and allows for runtime type
  34 /// hierarchy checks.
  35 /// Use getFromNodeKind<T>() to construct them.
  36 class ASTNodeKind {
  37 public:
  38   /// \brief Empty identifier. It matches nothing.
  39   ASTNodeKind() : KindId(NKI_None) {}
  40
  41   /// \brief Construct an identifier for T.
  42   template <class T>
  43   static ASTNodeKind getFromNodeKind() {
  44     return ASTNodeKind(KindToKindId<T>::Id);
  45   }
  46
  47   /// \brief Returns \c true if \c this and \c Other represent the same kind.
  48   bool isSame(ASTNodeKind Other) const;
  49
  50   /// \brief Returns \c true if \c this is a base kind of (or same as) \c Other.
  51   bool isBaseOf(ASTNodeKind Other) const;
  52
  53   /// \brief String representation of the kind.
  54   StringRef asStringRef() const;
  55
  56 private:
  57   /// \brief Kind ids.
  58   ///
  59   /// Includes all possible base and derived kinds.
  60   enum NodeKindId {
  61     NKI_None,
  62     NKI_CXXCtorInitializer,
  63     NKI_TemplateArgument,
  64     NKI_NestedNameSpecifier,
  65     NKI_NestedNameSpecifierLoc,
  66     NKI_QualType,
  67     NKI_TypeLoc,
  68     NKI_Decl,
  69 #define DECL(DERIVED, BASE) NKI_##DERIVED##Decl,
  70 #include "clang/AST/DeclNodes.inc"
  71     NKI_Stmt,
  72 #define STMT(DERIVED, BASE) NKI_##DERIVED,
  73 #include "clang/AST/StmtNodes.inc"
  74     NKI_Type,
  75 #define TYPE(DERIVED, BASE) NKI_##DERIVED##Type,
  76 #include "clang/AST/TypeNodes.def"
  77     NKI_NumberOfKinds
  78   };
  79
  80   /// \brief Use getFromNodeKind<T>() to construct the kind.
  81   ASTNodeKind(NodeKindId KindId) : KindId(KindId) {}
  82
  83   /// \brief Returns \c true if \c Base is a base kind of (or same as) \c
  84   ///   Derived.
  85   static bool isBaseOf(NodeKindId Base, NodeKindId Derived);
  86
  87   /// \brief Helper meta-function to convert a kind T to its enum value.
  88   ///
  89   /// This struct is specialized below for all known kinds.
  90   template <class T> struct KindToKindId {
  91     static const NodeKindId Id = NKI_None;
  92   };
  93
  94   /// \brief Per kind info.
  95   struct KindInfo {
  96     /// \brief The id of the parent kind, or None if it has no parent.
  97     NodeKindId ParentId;
  98     /// \brief Name of the kind.
  99     const char *Name;
 100   };
 101   static const KindInfo AllKindInfo[NKI_NumberOfKinds];
 102
 103   NodeKindId KindId;
 104 };
 105
 106 #define KIND_TO_KIND_ID(Class)                                                 \
 107   template <> struct ASTNodeKind::KindToKindId<Class> {                        \
 108     static const NodeKindId Id = NKI_##Class;                                  \
 109   };
 110 KIND_TO_KIND_ID(CXXCtorInitializer)
 111 KIND_TO_KIND_ID(TemplateArgument)
 112 KIND_TO_KIND_ID(NestedNameSpecifier)
 113 KIND_TO_KIND_ID(NestedNameSpecifierLoc)
 114 KIND_TO_KIND_ID(QualType)
 115 KIND_TO_KIND_ID(TypeLoc)
 116 KIND_TO_KIND_ID(Decl)
 117 KIND_TO_KIND_ID(Stmt)
 118 KIND_TO_KIND_ID(Type)
 119 #define DECL(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Decl)
 120 #include "clang/AST/DeclNodes.inc"
 121 #define STMT(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED)
 122 #include "clang/AST/StmtNodes.inc"
 123 #define TYPE(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Type)
 124 #include "clang/AST/TypeNodes.def"
 125 #undef KIND_TO_KIND_ID
 126
 127 /// \brief A dynamically typed AST node container.
 128 ///
 129 /// Stores an AST node in a type safe way. This allows writing code that
 130 /// works with different kinds of AST nodes, despite the fact that they don't
 131 /// have a common base class.
 132 ///
 133 /// Use \c create(Node) to create a \c DynTypedNode from an AST node,
 134 /// and \c get<T>() to retrieve the node as type T if the types match.
 135 ///
 136 /// See \c ASTNodeKind for which node base types are currently supported;
 137 /// You can create DynTypedNodes for all nodes in the inheritance hierarchy of
 138 /// the supported base types.
 139 class DynTypedNode {
 140 public:
 141   /// \brief Creates a \c DynTypedNode from \c Node.
 142   template <typename T>
 143   static DynTypedNode create(const T &Node) {
 144     return BaseConverter<T>::create(Node);
 145   }
 146
 147   /// \brief Retrieve the stored node as type \c T.
 148   ///
 149   /// Returns NULL if the stored node does not have a type that is
 150   /// convertible to \c T.
 151   ///
 152   /// For types that have identity via their pointer in the AST
 153   /// (like \c Stmt, \c Decl, \c Type and \c NestedNameSpecifier) the returned
 154   /// pointer points to the referenced AST node.
 155   /// For other types (like \c QualType) the value is stored directly
 156   /// in the \c DynTypedNode, and the returned pointer points at
 157   /// the storage inside DynTypedNode. For those nodes, do not
 158   /// use the pointer outside the scope of the DynTypedNode.
 159   template <typename T>
 160   const T *get() const {
 161     return BaseConverter<T>::get(NodeKind, Storage.buffer);
 162   }
 163
 164   /// \brief Returns a pointer that identifies the stored AST node.
 165   ///
 166   /// Note that this is not supported by all AST nodes. For AST nodes
 167   /// that don't have a pointer-defined identity inside the AST, this
 168   /// method returns NULL.
 169   const void *getMemoizationData() const;
 170
 171   /// @{
 172   /// \brief Imposes an order on \c DynTypedNode.
 173   ///
 174   /// Supports comparison of nodes that support memoization.
 175   /// FIXME: Implement comparsion for other node types (currently
 176   /// only Stmt, Decl, Type and NestedNameSpecifier return memoization data).
 177   bool operator<(const DynTypedNode &Other) const {
 178     assert(getMemoizationData() && Other.getMemoizationData());
 179     return getMemoizationData() < Other.getMemoizationData();
 180   }
 181   bool operator==(const DynTypedNode &Other) const {
 182     // Nodes with different types cannot be equal.
 183     if (!NodeKind.isSame(Other.NodeKind))
 184       return false;
 185
 186     // FIXME: Implement for other types.
 187     if (ASTNodeKind::getFromNodeKind<QualType>().isBaseOf(NodeKind)) {
 188       return *get<QualType>() == *Other.get<QualType>();
 189     }
 190     assert(getMemoizationData() && Other.getMemoizationData());
 191     return getMemoizationData() == Other.getMemoizationData();
 192   }
 193   bool operator!=(const DynTypedNode &Other) const {
 194     return !operator==(Other);
 195   }
 196   /// @}
 197
 198 private:
 199   /// \brief Takes care of converting from and to \c T.
 200   template <typename T, typename EnablerT = void> struct BaseConverter;
 201
 202   /// \brief Converter that uses dyn_cast<T> from a stored BaseT*.
 203   template <typename T, typename BaseT> struct DynCastPtrConverter {
 204     static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
 205       if (ASTNodeKind::getFromNodeKind<BaseT>().isBaseOf(NodeKind))
 206         return dyn_cast<T>(*reinterpret_cast<BaseT *const *>(Storage));
 207       return NULL;
 208     }
 209     static DynTypedNode create(const BaseT &Node) {
 210       DynTypedNode Result;
 211       Result.NodeKind = ASTNodeKind::getFromNodeKind<T>();
 212       new (Result.Storage.buffer) const BaseT * (&Node);
 213       return Result;
 214     }
 215   };
 216
 217   /// \brief Converter that stores T* (by pointer).
 218   template <typename T> struct PtrConverter {
 219     static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
 220       if (ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind))
 221         return *reinterpret_cast<T *const *>(Storage);
 222       return NULL;
 223     }
 224     static DynTypedNode create(const T &Node) {
 225       DynTypedNode Result;
 226       Result.NodeKind = ASTNodeKind::getFromNodeKind<T>();
 227       new (Result.Storage.buffer) const T * (&Node);
 228       return Result;
 229     }
 230   };
 231
 232   /// \brief Converter that stores T (by value).
 233   template <typename T> struct ValueConverter {
 234     static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
 235       if (ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind))
 236         return reinterpret_cast<const T *>(Storage);
 237       return NULL;
 238     }
 239     static DynTypedNode create(const T &Node) {
 240       DynTypedNode Result;
 241       Result.NodeKind = ASTNodeKind::getFromNodeKind<T>();
 242       new (Result.Storage.buffer) T(Node);
 243       return Result;
 244     }
 245   };
 246
 247   ASTNodeKind NodeKind;
 248
 249   /// \brief Stores the data of the node.
 250   ///
 251   /// Note that we can store \c Decls, \c Stmts, \c Types,
 252   /// \c NestedNameSpecifiers and \c CXXCtorInitializer by pointer as they are
 253   /// guaranteed to be unique pointers pointing to dedicated storage in the AST.
 254   /// \c QualTypes, \c NestedNameSpecifierLocs, \c TypeLocs and
 255   /// \c TemplateArguments on the other hand do not have storage or unique
 256   /// pointers and thus need to be stored by value.
 257   typedef llvm::AlignedCharArrayUnion<
 258       Decl *, Stmt *, Type *, NestedNameSpecifier *, CXXCtorInitializer *>
 259       KindsByPointer;
 260   llvm::AlignedCharArrayUnion<KindsByPointer, TemplateArgument,
 261                               NestedNameSpecifierLoc, QualType, TypeLoc>
 262       Storage;
 263 };
 264
 265 template <typename T>
 266 struct DynTypedNode::BaseConverter<
 267     T, typename llvm::enable_if<llvm::is_base_of<
 268            Decl, T> >::type> : public DynCastPtrConverter<T, Decl> {};
 269
 270 template <typename T>
 271 struct DynTypedNode::BaseConverter<
 272     T, typename llvm::enable_if<llvm::is_base_of<
 273            Stmt, T> >::type> : public DynCastPtrConverter<T, Stmt> {};
 274
 275 template <typename T>
 276 struct DynTypedNode::BaseConverter<
 277     T, typename llvm::enable_if<llvm::is_base_of<
 278            Type, T> >::type> : public DynCastPtrConverter<T, Type> {};
 279
 280 template <>
 281 struct DynTypedNode::BaseConverter<
 282     NestedNameSpecifier, void> : public PtrConverter<NestedNameSpecifier> {};
 283
 284 template <>
 285 struct DynTypedNode::BaseConverter<
 286     CXXCtorInitializer, void> : public PtrConverter<CXXCtorInitializer> {};
 287
 288 template <>
 289 struct DynTypedNode::BaseConverter<
 290     TemplateArgument, void> : public ValueConverter<TemplateArgument> {};
 291
 292 template <>
 293 struct DynTypedNode::BaseConverter<
 294     NestedNameSpecifierLoc,
 295     void> : public ValueConverter<NestedNameSpecifierLoc> {};
 296
 297 template <>
 298 struct DynTypedNode::BaseConverter<QualType,
 299                                    void> : public ValueConverter<QualType> {};
 300
 301 template <>
 302 struct DynTypedNode::BaseConverter<
 303     TypeLoc, void> : public ValueConverter<TypeLoc> {};
 304
 305 // The only operation we allow on unsupported types is \c get.
 306 // This allows to conveniently use \c DynTypedNode when having an arbitrary
 307 // AST node that is not supported, but prevents misuse - a user cannot create
 308 // a DynTypedNode from arbitrary types.
 309 template <typename T, typename EnablerT> struct DynTypedNode::BaseConverter {
 310   static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
 311     return NULL;
 312   }
 313 };
 314
 315 inline const void *DynTypedNode::getMemoizationData() const {
 316   if (ASTNodeKind::getFromNodeKind<Decl>().isBaseOf(NodeKind)) {
 317     return BaseConverter<Decl>::get(NodeKind, Storage.buffer);
 318   } else if (ASTNodeKind::getFromNodeKind<Stmt>().isBaseOf(NodeKind)) {
 319     return BaseConverter<Stmt>::get(NodeKind, Storage.buffer);
 320   } else if (ASTNodeKind::getFromNodeKind<Type>().isBaseOf(NodeKind)) {
 321     return BaseConverter<Type>::get(NodeKind, Storage.buffer);
 322   } else if (ASTNodeKind::getFromNodeKind<NestedNameSpecifier>().isBaseOf(NodeKind)) {
 323     return BaseConverter<NestedNameSpecifier>::get(NodeKind, Storage.buffer);
 324   }
 325   return NULL;
 326 }
 327
 328 } // end namespace ast_type_traits
 329 } // end namespace clang
 330
 331 #endif // LLVM_CLANG_AST_AST_TYPE_TRAITS_H