Home | History | Annotate | Download | only in libclang 
      1 //===- CXTypes.cpp - Implements 'CXTypes' aspect of libclang ------------===//
      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 // This file implements the 'CXTypes' API hooks in the Clang-C library.
     11 //
     12 //===--------------------------------------------------------------------===//
     13 
     14 #include "CIndexer.h"
     15 #include "CXCursor.h"
     16 #include "CXString.h"
     17 #include "CXTranslationUnit.h"
     18 #include "CXType.h"
     19 #include "clang/AST/Decl.h"
     20 #include "clang/AST/DeclObjC.h"
     21 #include "clang/AST/DeclTemplate.h"
     22 #include "clang/AST/Expr.h"
     23 #include "clang/AST/Type.h"
     24 #include "clang/Frontend/ASTUnit.h"
     25 
     26 using namespace clang;
     27 
     28 static CXTypeKind GetBuiltinTypeKind(const BuiltinType *BT) {
     29 #define BTCASE(K) case BuiltinType::K: return CXType_##K
     30   switch (BT->getKind()) {
     31     BTCASE(Void);
     32     BTCASE(Bool);
     33     BTCASE(Char_U);
     34     BTCASE(UChar);
     35     BTCASE(Char16);
     36     BTCASE(Char32);
     37     BTCASE(UShort);
     38     BTCASE(UInt);
     39     BTCASE(ULong);
     40     BTCASE(ULongLong);
     41     BTCASE(UInt128);
     42     BTCASE(Char_S);
     43     BTCASE(SChar);
     44     case BuiltinType::WChar_S: return CXType_WChar;
     45     case BuiltinType::WChar_U: return CXType_WChar;
     46     BTCASE(Short);
     47     BTCASE(Int);
     48     BTCASE(Long);
     49     BTCASE(LongLong);
     50     BTCASE(Int128);
     51     BTCASE(Float);
     52     BTCASE(Double);
     53     BTCASE(LongDouble);
     54     BTCASE(NullPtr);
     55     BTCASE(Overload);
     56     BTCASE(Dependent);
     57     BTCASE(ObjCId);
     58     BTCASE(ObjCClass);
     59     BTCASE(ObjCSel);
     60   default:
     61     return CXType_Unexposed;
     62   }
     63 #undef BTCASE
     64 }
     65 
     66 static CXTypeKind GetTypeKind(QualType T) {
     67   const Type *TP = T.getTypePtrOrNull();
     68   if (!TP)
     69     return CXType_Invalid;
     70 
     71 #define TKCASE(K) case Type::K: return CXType_##K
     72   switch (TP->getTypeClass()) {
     73     case Type::Builtin:
     74       return GetBuiltinTypeKind(cast<BuiltinType>(TP));
     75     TKCASE(Complex);
     76     TKCASE(Pointer);
     77     TKCASE(BlockPointer);
     78     TKCASE(LValueReference);
     79     TKCASE(RValueReference);
     80     TKCASE(Record);
     81     TKCASE(Enum);
     82     TKCASE(Typedef);
     83     TKCASE(ObjCInterface);
     84     TKCASE(ObjCObjectPointer);
     85     TKCASE(FunctionNoProto);
     86     TKCASE(FunctionProto);
     87     TKCASE(ConstantArray);
     88     TKCASE(IncompleteArray);
     89     TKCASE(VariableArray);
     90     TKCASE(DependentSizedArray);
     91     TKCASE(Vector);
     92     TKCASE(MemberPointer);
     93     default:
     94       return CXType_Unexposed;
     95   }
     96 #undef TKCASE
     97 }
     98 
     99 
    100 CXType cxtype::MakeCXType(QualType T, CXTranslationUnit TU) {
    101   CXTypeKind TK = CXType_Invalid;
    102 
    103   if (TU && !T.isNull()) {
    104     ASTContext &Ctx = cxtu::getASTUnit(TU)->getASTContext();
    105     if (Ctx.getLangOpts().ObjC1) {
    106       QualType UnqualT = T.getUnqualifiedType();
    107       if (Ctx.isObjCIdType(UnqualT))
    108         TK = CXType_ObjCId;
    109       else if (Ctx.isObjCClassType(UnqualT))
    110         TK = CXType_ObjCClass;
    111       else if (Ctx.isObjCSelType(UnqualT))
    112         TK = CXType_ObjCSel;
    113     }
    114 
    115     /* Handle decayed types as the original type */
    116     if (const DecayedType *DT = T->getAs<DecayedType>()) {
    117       return MakeCXType(DT->getOriginalType(), TU);
    118     }
    119   }
    120   if (TK == CXType_Invalid)
    121     TK = GetTypeKind(T);
    122 
    123   CXType CT = { TK, { TK == CXType_Invalid ? nullptr
    124                                            : T.getAsOpaquePtr(), TU } };
    125   return CT;
    126 }
    127 
    128 using cxtype::MakeCXType;
    129 
    130 static inline QualType GetQualType(CXType CT) {
    131   return QualType::getFromOpaquePtr(CT.data[0]);
    132 }
    133 
    134 static inline CXTranslationUnit GetTU(CXType CT) {
    135   return static_cast<CXTranslationUnit>(CT.data[1]);
    136 }
    137 
    138 extern "C" {
    139 
    140 CXType clang_getCursorType(CXCursor C) {
    141   using namespace cxcursor;
    142 
    143   CXTranslationUnit TU = cxcursor::getCursorTU(C);
    144   if (!TU)
    145     return MakeCXType(QualType(), TU);
    146 
    147   ASTContext &Context = cxtu::getASTUnit(TU)->getASTContext();
    148   if (clang_isExpression(C.kind)) {
    149     QualType T = cxcursor::getCursorExpr(C)->getType();
    150     return MakeCXType(T, TU);
    151   }
    152 
    153   if (clang_isDeclaration(C.kind)) {
    154     const Decl *D = cxcursor::getCursorDecl(C);
    155     if (!D)
    156       return MakeCXType(QualType(), TU);
    157 
    158     if (const TypeDecl *TD = dyn_cast<TypeDecl>(D))
    159       return MakeCXType(Context.getTypeDeclType(TD), TU);
    160     if (const ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D))
    161       return MakeCXType(Context.getObjCInterfaceType(ID), TU);
    162     if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
    163       if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo())
    164         return MakeCXType(TSInfo->getType(), TU);
    165       return MakeCXType(DD->getType(), TU);
    166     }
    167     if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
    168       return MakeCXType(VD->getType(), TU);
    169     if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
    170       return MakeCXType(PD->getType(), TU);
    171     if (const FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D)) {
    172       if (TypeSourceInfo *TSInfo = FTD->getTemplatedDecl()->getTypeSourceInfo())
    173         return MakeCXType(TSInfo->getType(), TU);
    174       return MakeCXType(FTD->getTemplatedDecl()->getType(), TU);
    175     }
    176     return MakeCXType(QualType(), TU);
    177   }
    178 
    179   if (clang_isReference(C.kind)) {
    180     switch (C.kind) {
    181     case CXCursor_ObjCSuperClassRef: {
    182       QualType T
    183         = Context.getObjCInterfaceType(getCursorObjCSuperClassRef(C).first);
    184       return MakeCXType(T, TU);
    185     }
    186 
    187     case CXCursor_ObjCClassRef: {
    188       QualType T = Context.getObjCInterfaceType(getCursorObjCClassRef(C).first);
    189       return MakeCXType(T, TU);
    190     }
    191 
    192     case CXCursor_TypeRef: {
    193       QualType T = Context.getTypeDeclType(getCursorTypeRef(C).first);
    194       return MakeCXType(T, TU);
    195 
    196     }
    197 
    198     case CXCursor_CXXBaseSpecifier:
    199       return cxtype::MakeCXType(getCursorCXXBaseSpecifier(C)->getType(), TU);
    200 
    201     case CXCursor_MemberRef:
    202       return cxtype::MakeCXType(getCursorMemberRef(C).first->getType(), TU);
    203 
    204     case CXCursor_VariableRef:
    205       return cxtype::MakeCXType(getCursorVariableRef(C).first->getType(), TU);
    206 
    207     case CXCursor_ObjCProtocolRef:
    208     case CXCursor_TemplateRef:
    209     case CXCursor_NamespaceRef:
    210     case CXCursor_OverloadedDeclRef:
    211     default:
    212       break;
    213     }
    214 
    215     return MakeCXType(QualType(), TU);
    216   }
    217 
    218   return MakeCXType(QualType(), TU);
    219 }
    220 
    221 CXString clang_getTypeSpelling(CXType CT) {
    222   QualType T = GetQualType(CT);
    223   if (T.isNull())
    224     return cxstring::createEmpty();
    225 
    226   CXTranslationUnit TU = GetTU(CT);
    227   SmallString<64> Str;
    228   llvm::raw_svector_ostream OS(Str);
    229   PrintingPolicy PP(cxtu::getASTUnit(TU)->getASTContext().getLangOpts());
    230 
    231   T.print(OS, PP);
    232 
    233   return cxstring::createDup(OS.str());
    234 }
    235 
    236 CXType clang_getTypedefDeclUnderlyingType(CXCursor C) {
    237   using namespace cxcursor;
    238   CXTranslationUnit TU = cxcursor::getCursorTU(C);
    239 
    240   if (clang_isDeclaration(C.kind)) {
    241     const Decl *D = cxcursor::getCursorDecl(C);
    242 
    243     if (const TypedefNameDecl *TD = dyn_cast_or_null<TypedefNameDecl>(D)) {
    244       QualType T = TD->getUnderlyingType();
    245       return MakeCXType(T, TU);
    246     }
    247 
    248     return MakeCXType(QualType(), TU);
    249   }
    250 
    251   return MakeCXType(QualType(), TU);
    252 }
    253 
    254 CXType clang_getEnumDeclIntegerType(CXCursor C) {
    255   using namespace cxcursor;
    256   CXTranslationUnit TU = cxcursor::getCursorTU(C);
    257 
    258   if (clang_isDeclaration(C.kind)) {
    259     const Decl *D = cxcursor::getCursorDecl(C);
    260 
    261     if (const EnumDecl *TD = dyn_cast_or_null<EnumDecl>(D)) {
    262       QualType T = TD->getIntegerType();
    263       return MakeCXType(T, TU);
    264     }
    265 
    266     return MakeCXType(QualType(), TU);
    267   }
    268 
    269   return MakeCXType(QualType(), TU);
    270 }
    271 
    272 long long clang_getEnumConstantDeclValue(CXCursor C) {
    273   using namespace cxcursor;
    274 
    275   if (clang_isDeclaration(C.kind)) {
    276     const Decl *D = cxcursor::getCursorDecl(C);
    277 
    278     if (const EnumConstantDecl *TD = dyn_cast_or_null<EnumConstantDecl>(D)) {
    279       return TD->getInitVal().getSExtValue();
    280     }
    281 
    282     return LLONG_MIN;
    283   }
    284 
    285   return LLONG_MIN;
    286 }
    287 
    288 unsigned long long clang_getEnumConstantDeclUnsignedValue(CXCursor C) {
    289   using namespace cxcursor;
    290 
    291   if (clang_isDeclaration(C.kind)) {
    292     const Decl *D = cxcursor::getCursorDecl(C);
    293 
    294     if (const EnumConstantDecl *TD = dyn_cast_or_null<EnumConstantDecl>(D)) {
    295       return TD->getInitVal().getZExtValue();
    296     }
    297 
    298     return ULLONG_MAX;
    299   }
    300 
    301   return ULLONG_MAX;
    302 }
    303 
    304 int clang_getFieldDeclBitWidth(CXCursor C) {
    305   using namespace cxcursor;
    306 
    307   if (clang_isDeclaration(C.kind)) {
    308     const Decl *D = getCursorDecl(C);
    309 
    310     if (const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {
    311       if (FD->isBitField())
    312         return FD->getBitWidthValue(getCursorContext(C));
    313     }
    314   }
    315 
    316   return -1;
    317 }
    318 
    319 CXType clang_getCanonicalType(CXType CT) {
    320   if (CT.kind == CXType_Invalid)
    321     return CT;
    322 
    323   QualType T = GetQualType(CT);
    324   CXTranslationUnit TU = GetTU(CT);
    325 
    326   if (T.isNull())
    327     return MakeCXType(QualType(), GetTU(CT));
    328 
    329   return MakeCXType(cxtu::getASTUnit(TU)->getASTContext()
    330                         .getCanonicalType(T),
    331                     TU);
    332 }
    333 
    334 unsigned clang_isConstQualifiedType(CXType CT) {
    335   QualType T = GetQualType(CT);
    336   return T.isLocalConstQualified();
    337 }
    338 
    339 unsigned clang_isVolatileQualifiedType(CXType CT) {
    340   QualType T = GetQualType(CT);
    341   return T.isLocalVolatileQualified();
    342 }
    343 
    344 unsigned clang_isRestrictQualifiedType(CXType CT) {
    345   QualType T = GetQualType(CT);
    346   return T.isLocalRestrictQualified();
    347 }
    348 
    349 CXType clang_getPointeeType(CXType CT) {
    350   QualType T = GetQualType(CT);
    351   const Type *TP = T.getTypePtrOrNull();
    352 
    353   if (!TP)
    354     return MakeCXType(QualType(), GetTU(CT));
    355 
    356   switch (TP->getTypeClass()) {
    357     case Type::Pointer:
    358       T = cast<PointerType>(TP)->getPointeeType();
    359       break;
    360     case Type::BlockPointer:
    361       T = cast<BlockPointerType>(TP)->getPointeeType();
    362       break;
    363     case Type::LValueReference:
    364     case Type::RValueReference:
    365       T = cast<ReferenceType>(TP)->getPointeeType();
    366       break;
    367     case Type::ObjCObjectPointer:
    368       T = cast<ObjCObjectPointerType>(TP)->getPointeeType();
    369       break;
    370     case Type::MemberPointer:
    371       T = cast<MemberPointerType>(TP)->getPointeeType();
    372       break;
    373     default:
    374       T = QualType();
    375       break;
    376   }
    377   return MakeCXType(T, GetTU(CT));
    378 }
    379 
    380 CXCursor clang_getTypeDeclaration(CXType CT) {
    381   if (CT.kind == CXType_Invalid)
    382     return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound);
    383 
    384   QualType T = GetQualType(CT);
    385   const Type *TP = T.getTypePtrOrNull();
    386 
    387   if (!TP)
    388     return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound);
    389 
    390   Decl *D = nullptr;
    391 
    392 try_again:
    393   switch (TP->getTypeClass()) {
    394   case Type::Typedef:
    395     D = cast<TypedefType>(TP)->getDecl();
    396     break;
    397   case Type::ObjCObject:
    398     D = cast<ObjCObjectType>(TP)->getInterface();
    399     break;
    400   case Type::ObjCInterface:
    401     D = cast<ObjCInterfaceType>(TP)->getDecl();
    402     break;
    403   case Type::Record:
    404   case Type::Enum:
    405     D = cast<TagType>(TP)->getDecl();
    406     break;
    407   case Type::TemplateSpecialization:
    408     if (const RecordType *Record = TP->getAs<RecordType>())
    409       D = Record->getDecl();
    410     else
    411       D = cast<TemplateSpecializationType>(TP)->getTemplateName()
    412                                                          .getAsTemplateDecl();
    413     break;
    414 
    415   case Type::InjectedClassName:
    416     D = cast<InjectedClassNameType>(TP)->getDecl();
    417     break;
    418 
    419   // FIXME: Template type parameters!
    420 
    421   case Type::Elaborated:
    422     TP = cast<ElaboratedType>(TP)->getNamedType().getTypePtrOrNull();
    423     goto try_again;
    424 
    425   default:
    426     break;
    427   }
    428 
    429   if (!D)
    430     return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound);
    431 
    432   return cxcursor::MakeCXCursor(D, GetTU(CT));
    433 }
    434 
    435 CXString clang_getTypeKindSpelling(enum CXTypeKind K) {
    436   const char *s = nullptr;
    437 #define TKIND(X) case CXType_##X: s = ""  #X  ""; break
    438   switch (K) {
    439     TKIND(Invalid);
    440     TKIND(Unexposed);
    441     TKIND(Void);
    442     TKIND(Bool);
    443     TKIND(Char_U);
    444     TKIND(UChar);
    445     TKIND(Char16);
    446     TKIND(Char32);
    447     TKIND(UShort);
    448     TKIND(UInt);
    449     TKIND(ULong);
    450     TKIND(ULongLong);
    451     TKIND(UInt128);
    452     TKIND(Char_S);
    453     TKIND(SChar);
    454     case CXType_WChar: s = "WChar"; break;
    455     TKIND(Short);
    456     TKIND(Int);
    457     TKIND(Long);
    458     TKIND(LongLong);
    459     TKIND(Int128);
    460     TKIND(Float);
    461     TKIND(Double);
    462     TKIND(LongDouble);
    463     TKIND(NullPtr);
    464     TKIND(Overload);
    465     TKIND(Dependent);
    466     TKIND(ObjCId);
    467     TKIND(ObjCClass);
    468     TKIND(ObjCSel);
    469     TKIND(Complex);
    470     TKIND(Pointer);
    471     TKIND(BlockPointer);
    472     TKIND(LValueReference);
    473     TKIND(RValueReference);
    474     TKIND(Record);
    475     TKIND(Enum);
    476     TKIND(Typedef);
    477     TKIND(ObjCInterface);
    478     TKIND(ObjCObjectPointer);
    479     TKIND(FunctionNoProto);
    480     TKIND(FunctionProto);
    481     TKIND(ConstantArray);
    482     TKIND(IncompleteArray);
    483     TKIND(VariableArray);
    484     TKIND(DependentSizedArray);
    485     TKIND(Vector);
    486     TKIND(MemberPointer);
    487   }
    488 #undef TKIND
    489   return cxstring::createRef(s);
    490 }
    491 
    492 unsigned clang_equalTypes(CXType A, CXType B) {
    493   return A.data[0] == B.data[0] && A.data[1] == B.data[1];;
    494 }
    495 
    496 unsigned clang_isFunctionTypeVariadic(CXType X) {
    497   QualType T = GetQualType(X);
    498   if (T.isNull())
    499     return 0;
    500 
    501   if (const FunctionProtoType *FD = T->getAs<FunctionProtoType>())
    502     return (unsigned)FD->isVariadic();
    503 
    504   if (T->getAs<FunctionNoProtoType>())
    505     return 1;
    506 
    507   return 0;
    508 }
    509 
    510 CXCallingConv clang_getFunctionTypeCallingConv(CXType X) {
    511   QualType T = GetQualType(X);
    512   if (T.isNull())
    513     return CXCallingConv_Invalid;
    514 
    515   if (const FunctionType *FD = T->getAs<FunctionType>()) {
    516 #define TCALLINGCONV(X) case CC_##X: return CXCallingConv_##X
    517     switch (FD->getCallConv()) {
    518       TCALLINGCONV(C);
    519       TCALLINGCONV(X86StdCall);
    520       TCALLINGCONV(X86FastCall);
    521       TCALLINGCONV(X86ThisCall);
    522       TCALLINGCONV(X86Pascal);
    523       TCALLINGCONV(X86VectorCall);
    524       TCALLINGCONV(X86_64Win64);
    525       TCALLINGCONV(X86_64SysV);
    526       TCALLINGCONV(AAPCS);
    527       TCALLINGCONV(AAPCS_VFP);
    528       TCALLINGCONV(IntelOclBicc);
    529     case CC_SpirFunction: return CXCallingConv_Unexposed;
    530     case CC_SpirKernel: return CXCallingConv_Unexposed;
    531       break;
    532     }
    533 #undef TCALLINGCONV
    534   }
    535 
    536   return CXCallingConv_Invalid;
    537 }
    538 
    539 int clang_getNumArgTypes(CXType X) {
    540   QualType T = GetQualType(X);
    541   if (T.isNull())
    542     return -1;
    543 
    544   if (const FunctionProtoType *FD = T->getAs<FunctionProtoType>()) {
    545     return FD->getNumParams();
    546   }
    547 
    548   if (T->getAs<FunctionNoProtoType>()) {
    549     return 0;
    550   }
    551 
    552   return -1;
    553 }
    554 
    555 CXType clang_getArgType(CXType X, unsigned i) {
    556   QualType T = GetQualType(X);
    557   if (T.isNull())
    558     return MakeCXType(QualType(), GetTU(X));
    559 
    560   if (const FunctionProtoType *FD = T->getAs<FunctionProtoType>()) {
    561     unsigned numParams = FD->getNumParams();
    562     if (i >= numParams)
    563       return MakeCXType(QualType(), GetTU(X));
    564 
    565     return MakeCXType(FD->getParamType(i), GetTU(X));
    566   }
    567 
    568   return MakeCXType(QualType(), GetTU(X));
    569 }
    570 
    571 CXType clang_getResultType(CXType X) {
    572   QualType T = GetQualType(X);
    573   if (T.isNull())
    574     return MakeCXType(QualType(), GetTU(X));
    575 
    576   if (const FunctionType *FD = T->getAs<FunctionType>())
    577     return MakeCXType(FD->getReturnType(), GetTU(X));
    578 
    579   return MakeCXType(QualType(), GetTU(X));
    580 }
    581 
    582 CXType clang_getCursorResultType(CXCursor C) {
    583   if (clang_isDeclaration(C.kind)) {
    584     const Decl *D = cxcursor::getCursorDecl(C);
    585     if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D))
    586       return MakeCXType(MD->getReturnType(), cxcursor::getCursorTU(C));
    587 
    588     return clang_getResultType(clang_getCursorType(C));
    589   }
    590 
    591   return MakeCXType(QualType(), cxcursor::getCursorTU(C));
    592 }
    593 
    594 unsigned clang_isPODType(CXType X) {
    595   QualType T = GetQualType(X);
    596   if (T.isNull())
    597     return 0;
    598 
    599   CXTranslationUnit TU = GetTU(X);
    600 
    601   return T.isPODType(cxtu::getASTUnit(TU)->getASTContext()) ? 1 : 0;
    602 }
    603 
    604 CXType clang_getElementType(CXType CT) {
    605   QualType ET = QualType();
    606   QualType T = GetQualType(CT);
    607   const Type *TP = T.getTypePtrOrNull();
    608 
    609   if (TP) {
    610     switch (TP->getTypeClass()) {
    611     case Type::ConstantArray:
    612       ET = cast<ConstantArrayType> (TP)->getElementType();
    613       break;
    614     case Type::IncompleteArray:
    615       ET = cast<IncompleteArrayType> (TP)->getElementType();
    616       break;
    617     case Type::VariableArray:
    618       ET = cast<VariableArrayType> (TP)->getElementType();
    619       break;
    620     case Type::DependentSizedArray:
    621       ET = cast<DependentSizedArrayType> (TP)->getElementType();
    622       break;
    623     case Type::Vector:
    624       ET = cast<VectorType> (TP)->getElementType();
    625       break;
    626     case Type::Complex:
    627       ET = cast<ComplexType> (TP)->getElementType();
    628       break;
    629     default:
    630       break;
    631     }
    632   }
    633   return MakeCXType(ET, GetTU(CT));
    634 }
    635 
    636 long long clang_getNumElements(CXType CT) {
    637   long long result = -1;
    638   QualType T = GetQualType(CT);
    639   const Type *TP = T.getTypePtrOrNull();
    640 
    641   if (TP) {
    642     switch (TP->getTypeClass()) {
    643     case Type::ConstantArray:
    644       result = cast<ConstantArrayType> (TP)->getSize().getSExtValue();
    645       break;
    646     case Type::Vector:
    647       result = cast<VectorType> (TP)->getNumElements();
    648       break;
    649     default:
    650       break;
    651     }
    652   }
    653   return result;
    654 }
    655 
    656 CXType clang_getArrayElementType(CXType CT) {
    657   QualType ET = QualType();
    658   QualType T = GetQualType(CT);
    659   const Type *TP = T.getTypePtrOrNull();
    660 
    661   if (TP) {
    662     switch (TP->getTypeClass()) {
    663     case Type::ConstantArray:
    664       ET = cast<ConstantArrayType> (TP)->getElementType();
    665       break;
    666     case Type::IncompleteArray:
    667       ET = cast<IncompleteArrayType> (TP)->getElementType();
    668       break;
    669     case Type::VariableArray:
    670       ET = cast<VariableArrayType> (TP)->getElementType();
    671       break;
    672     case Type::DependentSizedArray:
    673       ET = cast<DependentSizedArrayType> (TP)->getElementType();
    674       break;
    675     default:
    676       break;
    677     }
    678   }
    679   return MakeCXType(ET, GetTU(CT));
    680 }
    681 
    682 long long clang_getArraySize(CXType CT) {
    683   long long result = -1;
    684   QualType T = GetQualType(CT);
    685   const Type *TP = T.getTypePtrOrNull();
    686 
    687   if (TP) {
    688     switch (TP->getTypeClass()) {
    689     case Type::ConstantArray:
    690       result = cast<ConstantArrayType> (TP)->getSize().getSExtValue();
    691       break;
    692     default:
    693       break;
    694     }
    695   }
    696   return result;
    697 }
    698 
    699 long long clang_Type_getAlignOf(CXType T) {
    700   if (T.kind == CXType_Invalid)
    701     return CXTypeLayoutError_Invalid;
    702   ASTContext &Ctx = cxtu::getASTUnit(GetTU(T))->getASTContext();
    703   QualType QT = GetQualType(T);
    704   // [expr.alignof] p1: return size_t value for complete object type, reference
    705   //                    or array.
    706   // [expr.alignof] p3: if reference type, return size of referenced type
    707   if (QT->isReferenceType())
    708     QT = QT.getNonReferenceType();
    709   if (QT->isIncompleteType())
    710     return CXTypeLayoutError_Incomplete;
    711   if (QT->isDependentType())
    712     return CXTypeLayoutError_Dependent;
    713   // Exceptions by GCC extension - see ASTContext.cpp:1313 getTypeInfoImpl
    714   // if (QT->isFunctionType()) return 4; // Bug #15511 - should be 1
    715   // if (QT->isVoidType()) return 1;
    716   return Ctx.getTypeAlignInChars(QT).getQuantity();
    717 }
    718 
    719 CXType clang_Type_getClassType(CXType CT) {
    720   QualType ET = QualType();
    721   QualType T = GetQualType(CT);
    722   const Type *TP = T.getTypePtrOrNull();
    723 
    724   if (TP && TP->getTypeClass() == Type::MemberPointer) {
    725     ET = QualType(cast<MemberPointerType> (TP)->getClass(), 0);
    726   }
    727   return MakeCXType(ET, GetTU(CT));
    728 }
    729 
    730 long long clang_Type_getSizeOf(CXType T) {
    731   if (T.kind == CXType_Invalid)
    732     return CXTypeLayoutError_Invalid;
    733   ASTContext &Ctx = cxtu::getASTUnit(GetTU(T))->getASTContext();
    734   QualType QT = GetQualType(T);
    735   // [expr.sizeof] p2: if reference type, return size of referenced type
    736   if (QT->isReferenceType())
    737     QT = QT.getNonReferenceType();
    738   // [expr.sizeof] p1: return -1 on: func, incomplete, bitfield, incomplete
    739   //                   enumeration
    740   // Note: We get the cxtype, not the cxcursor, so we can't call
    741   //       FieldDecl->isBitField()
    742   // [expr.sizeof] p3: pointer ok, function not ok.
    743   // [gcc extension] lib/AST/ExprConstant.cpp:1372 HandleSizeof : vla == error
    744   if (QT->isIncompleteType())
    745     return CXTypeLayoutError_Incomplete;
    746   if (QT->isDependentType())
    747     return CXTypeLayoutError_Dependent;
    748   if (!QT->isConstantSizeType())
    749     return CXTypeLayoutError_NotConstantSize;
    750   // [gcc extension] lib/AST/ExprConstant.cpp:1372
    751   //                 HandleSizeof : {voidtype,functype} == 1
    752   // not handled by ASTContext.cpp:1313 getTypeInfoImpl
    753   if (QT->isVoidType() || QT->isFunctionType())
    754     return 1;
    755   return Ctx.getTypeSizeInChars(QT).getQuantity();
    756 }
    757 
    758 static long long visitRecordForValidation(const RecordDecl *RD) {
    759   for (const auto *I : RD->fields()){
    760     QualType FQT = I->getType();
    761     if (FQT->isIncompleteType())
    762       return CXTypeLayoutError_Incomplete;
    763     if (FQT->isDependentType())
    764       return CXTypeLayoutError_Dependent;
    765     // recurse
    766     if (const RecordType *ChildType = I->getType()->getAs<RecordType>()) {
    767       if (const RecordDecl *Child = ChildType->getDecl()) {
    768         long long ret = visitRecordForValidation(Child);
    769         if (ret < 0)
    770           return ret;
    771       }
    772     }
    773     // else try next field
    774   }
    775   return 0;
    776 }
    777 
    778 static long long validateFieldParentType(CXCursor PC, CXType PT){
    779   if (clang_isInvalid(PC.kind))
    780     return CXTypeLayoutError_Invalid;
    781   const RecordDecl *RD =
    782         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
    783   // validate parent declaration
    784   if (!RD || RD->isInvalidDecl())
    785     return CXTypeLayoutError_Invalid;
    786   RD = RD->getDefinition();
    787   if (!RD)
    788     return CXTypeLayoutError_Incomplete;
    789   if (RD->isInvalidDecl())
    790     return CXTypeLayoutError_Invalid;
    791   // validate parent type
    792   QualType RT = GetQualType(PT);
    793   if (RT->isIncompleteType())
    794     return CXTypeLayoutError_Incomplete;
    795   if (RT->isDependentType())
    796     return CXTypeLayoutError_Dependent;
    797   // We recurse into all record fields to detect incomplete and dependent types.
    798   long long Error = visitRecordForValidation(RD);
    799   if (Error < 0)
    800     return Error;
    801   return 0;
    802 }
    803 
    804 long long clang_Type_getOffsetOf(CXType PT, const char *S) {
    805   // check that PT is not incomplete/dependent
    806   CXCursor PC = clang_getTypeDeclaration(PT);
    807   long long Error = validateFieldParentType(PC,PT);
    808   if (Error < 0)
    809     return Error;
    810   if (!S)
    811     return CXTypeLayoutError_InvalidFieldName;
    812   // lookup field
    813   ASTContext &Ctx = cxtu::getASTUnit(GetTU(PT))->getASTContext();
    814   IdentifierInfo *II = &Ctx.Idents.get(S);
    815   DeclarationName FieldName(II);
    816   const RecordDecl *RD =
    817         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
    818   // verified in validateFieldParentType
    819   RD = RD->getDefinition();
    820   RecordDecl::lookup_result Res = RD->lookup(FieldName);
    821   // If a field of the parent record is incomplete, lookup will fail.
    822   // and we would return InvalidFieldName instead of Incomplete.
    823   // But this erroneous results does protects again a hidden assertion failure
    824   // in the RecordLayoutBuilder
    825   if (Res.size() != 1)
    826     return CXTypeLayoutError_InvalidFieldName;
    827   if (const FieldDecl *FD = dyn_cast<FieldDecl>(Res.front()))
    828     return Ctx.getFieldOffset(FD);
    829   if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(Res.front()))
    830     return Ctx.getFieldOffset(IFD);
    831   // we don't want any other Decl Type.
    832   return CXTypeLayoutError_InvalidFieldName;
    833 }
    834 
    835 long long clang_Cursor_getOffsetOfField(CXCursor C) {
    836   if (clang_isDeclaration(C.kind)) {
    837     // we need to validate the parent type
    838     CXCursor PC = clang_getCursorSemanticParent(C);
    839     CXType PT = clang_getCursorType(PC);
    840     long long Error = validateFieldParentType(PC,PT);
    841     if (Error < 0)
    842       return Error;
    843     // proceed with the offset calculation
    844     const Decl *D = cxcursor::getCursorDecl(C);
    845     ASTContext &Ctx = cxcursor::getCursorContext(C);
    846     if (const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D))
    847       return Ctx.getFieldOffset(FD);
    848     if (const IndirectFieldDecl *IFD = dyn_cast_or_null<IndirectFieldDecl>(D))
    849       return Ctx.getFieldOffset(IFD);
    850   }
    851   return -1;
    852 }
    853 
    854 enum CXRefQualifierKind clang_Type_getCXXRefQualifier(CXType T) {
    855   QualType QT = GetQualType(T);
    856   if (QT.isNull())
    857     return CXRefQualifier_None;
    858   const FunctionProtoType *FD = QT->getAs<FunctionProtoType>();
    859   if (!FD)
    860     return CXRefQualifier_None;
    861   switch (FD->getRefQualifier()) {
    862     case RQ_None:
    863       return CXRefQualifier_None;
    864     case RQ_LValue:
    865       return CXRefQualifier_LValue;
    866     case RQ_RValue:
    867       return CXRefQualifier_RValue;
    868   }
    869   return CXRefQualifier_None;
    870 }
    871 
    872 unsigned clang_Cursor_isBitField(CXCursor C) {
    873   if (!clang_isDeclaration(C.kind))
    874     return 0;
    875   const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(cxcursor::getCursorDecl(C));
    876   if (!FD)
    877     return 0;
    878   return FD->isBitField();
    879 }
    880 
    881 CXString clang_getDeclObjCTypeEncoding(CXCursor C) {
    882   if (!clang_isDeclaration(C.kind))
    883     return cxstring::createEmpty();
    884 
    885   const Decl *D = cxcursor::getCursorDecl(C);
    886   ASTContext &Ctx = cxcursor::getCursorContext(C);
    887   std::string encoding;
    888 
    889   if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D))  {
    890     if (Ctx.getObjCEncodingForMethodDecl(OMD, encoding))
    891       return cxstring::createRef("?");
    892   } else if (const ObjCPropertyDecl *OPD = dyn_cast<ObjCPropertyDecl>(D))
    893     Ctx.getObjCEncodingForPropertyDecl(OPD, nullptr, encoding);
    894   else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
    895     Ctx.getObjCEncodingForFunctionDecl(FD, encoding);
    896   else {
    897     QualType Ty;
    898     if (const TypeDecl *TD = dyn_cast<TypeDecl>(D))
    899       Ty = Ctx.getTypeDeclType(TD);
    900     if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
    901       Ty = VD->getType();
    902     else return cxstring::createRef("?");
    903     Ctx.getObjCEncodingForType(Ty, encoding);
    904   }
    905 
    906   return cxstring::createDup(encoding);
    907 }
    908 
    909 int clang_Type_getNumTemplateArguments(CXType CT) {
    910   QualType T = GetQualType(CT);
    911   if (T.isNull())
    912     return -1;
    913   const CXXRecordDecl *RecordDecl = T->getAsCXXRecordDecl();
    914   if (!RecordDecl)
    915     return -1;
    916   const ClassTemplateSpecializationDecl *TemplateDecl =
    917       dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl);
    918   if (!TemplateDecl)
    919     return -1;
    920   return TemplateDecl->getTemplateArgs().size();
    921 }
    922 
    923 CXType clang_Type_getTemplateArgumentAsType(CXType CT, unsigned i) {
    924   QualType T = GetQualType(CT);
    925   if (T.isNull())
    926     return MakeCXType(QualType(), GetTU(CT));
    927   const CXXRecordDecl *RecordDecl = T->getAsCXXRecordDecl();
    928   if (!RecordDecl)
    929     return MakeCXType(QualType(), GetTU(CT));
    930   const ClassTemplateSpecializationDecl *TemplateDecl =
    931       dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl);
    932   if (!TemplateDecl)
    933     return MakeCXType(QualType(), GetTU(CT));
    934   const TemplateArgumentList &TA = TemplateDecl->getTemplateArgs();
    935   if (TA.size() <= i)
    936     return MakeCXType(QualType(), GetTU(CT));
    937   const TemplateArgument &A = TA.get(i);
    938   if (A.getKind() != TemplateArgument::Type)
    939     return MakeCXType(QualType(), GetTU(CT));
    940   return MakeCXType(A.getAsType(), GetTU(CT));
    941 }
    942 
    943 unsigned clang_Type_visitFields(CXType PT,
    944                                 CXFieldVisitor visitor,
    945                                 CXClientData client_data){
    946   CXCursor PC = clang_getTypeDeclaration(PT);
    947   if (clang_isInvalid(PC.kind))
    948     return false;
    949   const RecordDecl *RD =
    950         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
    951   if (!RD || RD->isInvalidDecl())
    952     return false;
    953   RD = RD->getDefinition();
    954   if (!RD || RD->isInvalidDecl())
    955     return false;
    956 
    957   for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
    958        I != E; ++I){
    959     const FieldDecl *FD = dyn_cast_or_null<FieldDecl>((*I));
    960     // Callback to the client.
    961     switch (visitor(cxcursor::MakeCXCursor(FD, GetTU(PT)), client_data)){
    962     case CXVisit_Break:
    963       return true;
    964     case CXVisit_Continue:
    965       break;
    966     }
    967   }
    968   return true;
    969 }
    970 
    971 unsigned clang_Cursor_isAnonymous(CXCursor C){
    972   if (!clang_isDeclaration(C.kind))
    973     return 0;
    974   const Decl *D = cxcursor::getCursorDecl(C);
    975   if (const RecordDecl *FD = dyn_cast_or_null<RecordDecl>(D))
    976     return FD->isAnonymousStructOrUnion();
    977   return 0;
    978 }
    979 
    980 } // end: extern "C"
    981