Home | History | Annotate | Download | only in AST 
      1 //===--- ASTTypeTraits.cpp --------------------------------------*- 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 #include "clang/AST/ASTTypeTraits.h"
     17 #include "clang/AST/ASTContext.h"
     18 #include "clang/AST/DeclCXX.h"
     19 
     20 namespace clang {
     21 namespace ast_type_traits {
     22 
     23 const ASTNodeKind::KindInfo ASTNodeKind::AllKindInfo[] = {
     24   { NKI_None, "<None>" },
     25   { NKI_None, "TemplateArgument" },
     26   { NKI_None, "NestedNameSpecifierLoc" },
     27   { NKI_None, "QualType" },
     28   { NKI_None, "TypeLoc" },
     29   { NKI_None, "CXXCtorInitializer" },
     30   { NKI_None, "NestedNameSpecifier" },
     31   { NKI_None, "Decl" },
     32 #define DECL(DERIVED, BASE) { NKI_##BASE, #DERIVED "Decl" },
     33 #include "clang/AST/DeclNodes.inc"
     34   { NKI_None, "Stmt" },
     35 #define STMT(DERIVED, BASE) { NKI_##BASE, #DERIVED },
     36 #include "clang/AST/StmtNodes.inc"
     37   { NKI_None, "Type" },
     38 #define TYPE(DERIVED, BASE) { NKI_##BASE, #DERIVED "Type" },
     39 #include "clang/AST/TypeNodes.def"
     40 };
     41 
     42 bool ASTNodeKind::isBaseOf(ASTNodeKind Other, unsigned *Distance) const {
     43   return isBaseOf(KindId, Other.KindId, Distance);
     44 }
     45 
     46 bool ASTNodeKind::isBaseOf(NodeKindId Base, NodeKindId Derived,
     47                            unsigned *Distance) {
     48   if (Base == NKI_None || Derived == NKI_None) return false;
     49   unsigned Dist = 0;
     50   while (Derived != Base && Derived != NKI_None) {
     51     Derived = AllKindInfo[Derived].ParentId;
     52     ++Dist;
     53   }
     54   if (Distance)
     55     *Distance = Dist;
     56   return Derived == Base;
     57 }
     58 
     59 StringRef ASTNodeKind::asStringRef() const { return AllKindInfo[KindId].Name; }
     60 
     61 ASTNodeKind ASTNodeKind::getMostDerivedType(ASTNodeKind Kind1,
     62                                             ASTNodeKind Kind2) {
     63   if (Kind1.isBaseOf(Kind2)) return Kind2;
     64   if (Kind2.isBaseOf(Kind1)) return Kind1;
     65   return ASTNodeKind();
     66 }
     67 
     68 ASTNodeKind ASTNodeKind::getMostDerivedCommonAncestor(ASTNodeKind Kind1,
     69                                                       ASTNodeKind Kind2) {
     70   NodeKindId Parent = Kind1.KindId;
     71   while (!isBaseOf(Parent, Kind2.KindId, nullptr) && Parent != NKI_None) {
     72     Parent = AllKindInfo[Parent].ParentId;
     73   }
     74   return ASTNodeKind(Parent);
     75 }
     76 
     77 ASTNodeKind ASTNodeKind::getFromNode(const Decl &D) {
     78   switch (D.getKind()) {
     79 #define DECL(DERIVED, BASE)                                                    \
     80     case Decl::DERIVED: return ASTNodeKind(NKI_##DERIVED##Decl);
     81 #define ABSTRACT_DECL(D)
     82 #include "clang/AST/DeclNodes.inc"
     83   };
     84   llvm_unreachable("invalid decl kind");
     85 }
     86 
     87 ASTNodeKind ASTNodeKind::getFromNode(const Stmt &S) {
     88   switch (S.getStmtClass()) {
     89     case Stmt::NoStmtClass: return NKI_None;
     90 #define STMT(CLASS, PARENT)                                                    \
     91     case Stmt::CLASS##Class: return ASTNodeKind(NKI_##CLASS);
     92 #define ABSTRACT_STMT(S)
     93 #include "clang/AST/StmtNodes.inc"
     94   }
     95   llvm_unreachable("invalid stmt kind");
     96 }
     97 
     98 ASTNodeKind ASTNodeKind::getFromNode(const Type &T) {
     99   switch (T.getTypeClass()) {
    100 #define TYPE(Class, Base)                                                      \
    101     case Type::Class: return ASTNodeKind(NKI_##Class##Type);
    102 #define ABSTRACT_TYPE(Class, Base)
    103 #include "clang/AST/TypeNodes.def"
    104   }
    105   llvm_unreachable("invalid type kind");
    106 }
    107 
    108 void DynTypedNode::print(llvm::raw_ostream &OS,
    109                          const PrintingPolicy &PP) const {
    110   if (const TemplateArgument *TA = get<TemplateArgument>())
    111     TA->print(PP, OS);
    112   else if (const NestedNameSpecifier *NNS = get<NestedNameSpecifier>())
    113     NNS->print(OS, PP);
    114   else if (const NestedNameSpecifierLoc *NNSL = get<NestedNameSpecifierLoc>())
    115     NNSL->getNestedNameSpecifier()->print(OS, PP);
    116   else if (const QualType *QT = get<QualType>())
    117     QT->print(OS, PP);
    118   else if (const TypeLoc *TL = get<TypeLoc>())
    119     TL->getType().print(OS, PP);
    120   else if (const Decl *D = get<Decl>())
    121     D->print(OS, PP);
    122   else if (const Stmt *S = get<Stmt>())
    123     S->printPretty(OS, nullptr, PP);
    124   else if (const Type *T = get<Type>())
    125     QualType(T, 0).print(OS, PP);
    126   else
    127     OS << "Unable to print values of type " << NodeKind.asStringRef() << "\n";
    128 }
    129 
    130 void DynTypedNode::dump(llvm::raw_ostream &OS, SourceManager &SM) const {
    131   if (const Decl *D = get<Decl>())
    132     D->dump(OS);
    133   else if (const Stmt *S = get<Stmt>())
    134     S->dump(OS, SM);
    135   else
    136     OS << "Unable to dump values of type " << NodeKind.asStringRef() << "\n";
    137 }
    138 
    139 SourceRange DynTypedNode::getSourceRange() const {
    140   if (const CXXCtorInitializer *CCI = get<CXXCtorInitializer>())
    141     return CCI->getSourceRange();
    142   if (const NestedNameSpecifierLoc *NNSL = get<NestedNameSpecifierLoc>())
    143     return NNSL->getSourceRange();
    144   if (const TypeLoc *TL = get<TypeLoc>())
    145     return TL->getSourceRange();
    146   if (const Decl *D = get<Decl>())
    147     return D->getSourceRange();
    148   if (const Stmt *S = get<Stmt>())
    149     return S->getSourceRange();
    150   return SourceRange();
    151 }
    152 
    153 } // end namespace ast_type_traits
    154 } // end namespace clang
    155