tools/libclang/CXType.cpp

   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/Basic/AddressSpaces.h"
  25 #include "clang/Frontend/ASTUnit.h"
  26
  27 using namespace clang;
  28
  29 static CXTypeKind GetBuiltinTypeKind(const BuiltinType *BT) {
  30 #define BTCASE(K) case BuiltinType::K: return CXType_##K
  31   switch (BT->getKind()) {
  32     BTCASE(Void);
  33     BTCASE(Bool);
  34     BTCASE(Char_U);
  35     BTCASE(UChar);
  36     BTCASE(Char16);
  37     BTCASE(Char32);
  38     BTCASE(UShort);
  39     BTCASE(UInt);
  40     BTCASE(ULong);
  41     BTCASE(ULongLong);
  42     BTCASE(UInt128);
  43     BTCASE(Char_S);
  44     BTCASE(SChar);
  45     case BuiltinType::WChar_S: return CXType_WChar;
  46     case BuiltinType::WChar_U: return CXType_WChar;
  47     BTCASE(Short);
  48     BTCASE(Int);
  49     BTCASE(Long);
  50     BTCASE(LongLong);
  51     BTCASE(Int128);
  52     BTCASE(Half);
  53     BTCASE(Float);
  54     BTCASE(Double);
  55     BTCASE(LongDouble);
  56     BTCASE(ShortAccum);
  57     BTCASE(Accum);
  58     BTCASE(LongAccum);
  59     BTCASE(UShortAccum);
  60     BTCASE(UAccum);
  61     BTCASE(ULongAccum);
  62     BTCASE(Float16);
  63     BTCASE(Float128);
  64     BTCASE(NullPtr);
  65     BTCASE(Overload);
  66     BTCASE(Dependent);
  67     BTCASE(ObjCId);
  68     BTCASE(ObjCClass);
  69     BTCASE(ObjCSel);
  70 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) BTCASE(Id);
  71 #include "clang/Basic/OpenCLImageTypes.def"
  72 #undef IMAGE_TYPE
  73 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) BTCASE(Id);
  74 #include "clang/Basic/OpenCLExtensionTypes.def"
  75     BTCASE(OCLSampler);
  76     BTCASE(OCLEvent);
  77     BTCASE(OCLQueue);
  78     BTCASE(OCLReserveID);
  79   default:
  80     return CXType_Unexposed;
  81   }
  82 #undef BTCASE
  83 }
  84
  85 static CXTypeKind GetTypeKind(QualType T) {
  86   const Type *TP = T.getTypePtrOrNull();
  87   if (!TP)
  88     return CXType_Invalid;
  89
  90 #define TKCASE(K) case Type::K: return CXType_##K
  91   switch (TP->getTypeClass()) {
  92     case Type::Builtin:
  93       return GetBuiltinTypeKind(cast<BuiltinType>(TP));
  94     TKCASE(Complex);
  95     TKCASE(Pointer);
  96     TKCASE(BlockPointer);
  97     TKCASE(LValueReference);
  98     TKCASE(RValueReference);
  99     TKCASE(Record);
 100     TKCASE(Enum);
 101     TKCASE(Typedef);
 102     TKCASE(ObjCInterface);
 103     TKCASE(ObjCObject);
 104     TKCASE(ObjCObjectPointer);
 105     TKCASE(ObjCTypeParam);
 106     TKCASE(FunctionNoProto);
 107     TKCASE(FunctionProto);
 108     TKCASE(ConstantArray);
 109     TKCASE(IncompleteArray);
 110     TKCASE(VariableArray);
 111     TKCASE(DependentSizedArray);
 112     TKCASE(Vector);
 113     TKCASE(MemberPointer);
 114     TKCASE(Auto);
 115     TKCASE(Elaborated);
 116     TKCASE(Pipe);
 117     TKCASE(Attributed);
 118     default:
 119       return CXType_Unexposed;
 120   }
 121 #undef TKCASE
 122 }
 123
 124
 125 CXType cxtype::MakeCXType(QualType T, CXTranslationUnit TU) {
 126   CXTypeKind TK = CXType_Invalid;
 127
 128   if (TU && !T.isNull()) {
 129     // Handle attributed types as the original type
 130     if (auto *ATT = T->getAs<AttributedType>()) {
 131       if (!(TU->ParsingOptions & CXTranslationUnit_IncludeAttributedTypes)) {
 132         return MakeCXType(ATT->getModifiedType(), TU);
 133       }
 134     }
 135     // Handle paren types as the original type
 136     if (auto *PTT = T->getAs<ParenType>()) {
 137       return MakeCXType(PTT->getInnerType(), TU);
 138     }
 139
 140     ASTContext &Ctx = cxtu::getASTUnit(TU)->getASTContext();
 141     if (Ctx.getLangOpts().ObjC) {
 142       QualType UnqualT = T.getUnqualifiedType();
 143       if (Ctx.isObjCIdType(UnqualT))
 144         TK = CXType_ObjCId;
 145       else if (Ctx.isObjCClassType(UnqualT))
 146         TK = CXType_ObjCClass;
 147       else if (Ctx.isObjCSelType(UnqualT))
 148         TK = CXType_ObjCSel;
 149     }
 150
 151     /* Handle decayed types as the original type */
 152     if (const DecayedType *DT = T->getAs<DecayedType>()) {
 153       return MakeCXType(DT->getOriginalType(), TU);
 154     }
 155   }
 156   if (TK == CXType_Invalid)
 157     TK = GetTypeKind(T);
 158
 159   CXType CT = { TK, { TK == CXType_Invalid ? nullptr
 160                                            : T.getAsOpaquePtr(), TU } };
 161   return CT;
 162 }
 163
 164 using cxtype::MakeCXType;
 165
 166 static inline QualType GetQualType(CXType CT) {
 167   return QualType::getFromOpaquePtr(CT.data[0]);
 168 }
 169
 170 static inline CXTranslationUnit GetTU(CXType CT) {
 171   return static_cast<CXTranslationUnit>(CT.data[1]);
 172 }
 173
 174 static Optional<ArrayRef<TemplateArgument>>
 175 GetTemplateArguments(QualType Type) {
 176   assert(!Type.isNull());
 177   if (const auto *Specialization = Type->getAs<TemplateSpecializationType>())
 178     return Specialization->template_arguments();
 179
 180   if (const auto *RecordDecl = Type->getAsCXXRecordDecl()) {
 181     const auto *TemplateDecl =
 182       dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl);
 183     if (TemplateDecl)
 184       return TemplateDecl->getTemplateArgs().asArray();
 185   }
 186
 187   return None;
 188 }
 189
 190 static Optional<QualType> TemplateArgumentToQualType(const TemplateArgument &A) {
 191   if (A.getKind() == TemplateArgument::Type)
 192     return A.getAsType();
 193   return None;
 194 }
 195
 196 static Optional<QualType>
 197 FindTemplateArgumentTypeAt(ArrayRef<TemplateArgument> TA, unsigned index) {
 198   unsigned current = 0;
 199   for (const auto &A : TA) {
 200     if (A.getKind() == TemplateArgument::Pack) {
 201       if (index < current + A.pack_size())
 202         return TemplateArgumentToQualType(A.getPackAsArray()[index - current]);
 203       current += A.pack_size();
 204       continue;
 205     }
 206     if (current == index)
 207       return TemplateArgumentToQualType(A);
 208     current++;
 209   }
 210   return None;
 211 }
 212
 213 CXType clang_getCursorType(CXCursor C) {
 214   using namespace cxcursor;
 215
 216   CXTranslationUnit TU = cxcursor::getCursorTU(C);
 217   if (!TU)
 218     return MakeCXType(QualType(), TU);
 219
 220   ASTContext &Context = cxtu::getASTUnit(TU)->getASTContext();
 221   if (clang_isExpression(C.kind)) {
 222     QualType T = cxcursor::getCursorExpr(C)->getType();
 223     return MakeCXType(T, TU);
 224   }
 225
 226   if (clang_isDeclaration(C.kind)) {
 227     const Decl *D = cxcursor::getCursorDecl(C);
 228     if (!D)
 229       return MakeCXType(QualType(), TU);
 230
 231     if (const TypeDecl *TD = dyn_cast<TypeDecl>(D))
 232       return MakeCXType(Context.getTypeDeclType(TD), TU);
 233     if (const ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D))
 234       return MakeCXType(Context.getObjCInterfaceType(ID), TU);
 235     if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D))
 236       return MakeCXType(DD->getType(), TU);
 237     if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
 238       return MakeCXType(VD->getType(), TU);
 239     if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
 240       return MakeCXType(PD->getType(), TU);
 241     if (const FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D))
 242       return MakeCXType(FTD->getTemplatedDecl()->getType(), TU);
 243     return MakeCXType(QualType(), TU);
 244   }
 245
 246   if (clang_isReference(C.kind)) {
 247     switch (C.kind) {
 248     case CXCursor_ObjCSuperClassRef: {
 249       QualType T
 250         = Context.getObjCInterfaceType(getCursorObjCSuperClassRef(C).first);
 251       return MakeCXType(T, TU);
 252     }
 253
 254     case CXCursor_ObjCClassRef: {
 255       QualType T = Context.getObjCInterfaceType(getCursorObjCClassRef(C).first);
 256       return MakeCXType(T, TU);
 257     }
 258
 259     case CXCursor_TypeRef: {
 260       QualType T = Context.getTypeDeclType(getCursorTypeRef(C).first);
 261       return MakeCXType(T, TU);
 262
 263     }
 264
 265     case CXCursor_CXXBaseSpecifier:
 266       return cxtype::MakeCXType(getCursorCXXBaseSpecifier(C)->getType(), TU);
 267
 268     case CXCursor_MemberRef:
 269       return cxtype::MakeCXType(getCursorMemberRef(C).first->getType(), TU);
 270
 271     case CXCursor_VariableRef:
 272       return cxtype::MakeCXType(getCursorVariableRef(C).first->getType(), TU);
 273
 274     case CXCursor_ObjCProtocolRef:
 275     case CXCursor_TemplateRef:
 276     case CXCursor_NamespaceRef:
 277     case CXCursor_OverloadedDeclRef:
 278     default:
 279       break;
 280     }
 281
 282     return MakeCXType(QualType(), TU);
 283   }
 284
 285   return MakeCXType(QualType(), TU);
 286 }
 287
 288 CXString clang_getTypeSpelling(CXType CT) {
 289   QualType T = GetQualType(CT);
 290   if (T.isNull())
 291     return cxstring::createEmpty();
 292
 293   CXTranslationUnit TU = GetTU(CT);
 294   SmallString<64> Str;
 295   llvm::raw_svector_ostream OS(Str);
 296   PrintingPolicy PP(cxtu::getASTUnit(TU)->getASTContext().getLangOpts());
 297
 298   T.print(OS, PP);
 299
 300   return cxstring::createDup(OS.str());
 301 }
 302
 303 CXType clang_getTypedefDeclUnderlyingType(CXCursor C) {
 304   using namespace cxcursor;
 305   CXTranslationUnit TU = cxcursor::getCursorTU(C);
 306
 307   if (clang_isDeclaration(C.kind)) {
 308     const Decl *D = cxcursor::getCursorDecl(C);
 309
 310     if (const TypedefNameDecl *TD = dyn_cast_or_null<TypedefNameDecl>(D)) {
 311       QualType T = TD->getUnderlyingType();
 312       return MakeCXType(T, TU);
 313     }
 314
 315     return MakeCXType(QualType(), TU);
 316   }
 317
 318   return MakeCXType(QualType(), TU);
 319 }
 320
 321 CXType clang_getEnumDeclIntegerType(CXCursor C) {
 322   using namespace cxcursor;
 323   CXTranslationUnit TU = cxcursor::getCursorTU(C);
 324
 325   if (clang_isDeclaration(C.kind)) {
 326     const Decl *D = cxcursor::getCursorDecl(C);
 327
 328     if (const EnumDecl *TD = dyn_cast_or_null<EnumDecl>(D)) {
 329       QualType T = TD->getIntegerType();
 330       return MakeCXType(T, TU);
 331     }
 332
 333     return MakeCXType(QualType(), TU);
 334   }
 335
 336   return MakeCXType(QualType(), TU);
 337 }
 338
 339 long long clang_getEnumConstantDeclValue(CXCursor C) {
 340   using namespace cxcursor;
 341
 342   if (clang_isDeclaration(C.kind)) {
 343     const Decl *D = cxcursor::getCursorDecl(C);
 344
 345     if (const EnumConstantDecl *TD = dyn_cast_or_null<EnumConstantDecl>(D)) {
 346       return TD->getInitVal().getSExtValue();
 347     }
 348
 349     return LLONG_MIN;
 350   }
 351
 352   return LLONG_MIN;
 353 }
 354
 355 unsigned long long clang_getEnumConstantDeclUnsignedValue(CXCursor C) {
 356   using namespace cxcursor;
 357
 358   if (clang_isDeclaration(C.kind)) {
 359     const Decl *D = cxcursor::getCursorDecl(C);
 360
 361     if (const EnumConstantDecl *TD = dyn_cast_or_null<EnumConstantDecl>(D)) {
 362       return TD->getInitVal().getZExtValue();
 363     }
 364
 365     return ULLONG_MAX;
 366   }
 367
 368   return ULLONG_MAX;
 369 }
 370
 371 int clang_getFieldDeclBitWidth(CXCursor C) {
 372   using namespace cxcursor;
 373
 374   if (clang_isDeclaration(C.kind)) {
 375     const Decl *D = getCursorDecl(C);
 376
 377     if (const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {
 378       if (FD->isBitField())
 379         return FD->getBitWidthValue(getCursorContext(C));
 380     }
 381   }
 382
 383   return -1;
 384 }
 385
 386 CXType clang_getCanonicalType(CXType CT) {
 387   if (CT.kind == CXType_Invalid)
 388     return CT;
 389
 390   QualType T = GetQualType(CT);
 391   CXTranslationUnit TU = GetTU(CT);
 392
 393   if (T.isNull())
 394     return MakeCXType(QualType(), GetTU(CT));
 395
 396   return MakeCXType(cxtu::getASTUnit(TU)->getASTContext()
 397                         .getCanonicalType(T),
 398                     TU);
 399 }
 400
 401 unsigned clang_isConstQualifiedType(CXType CT) {
 402   QualType T = GetQualType(CT);
 403   return T.isLocalConstQualified();
 404 }
 405
 406 unsigned clang_isVolatileQualifiedType(CXType CT) {
 407   QualType T = GetQualType(CT);
 408   return T.isLocalVolatileQualified();
 409 }
 410
 411 unsigned clang_isRestrictQualifiedType(CXType CT) {
 412   QualType T = GetQualType(CT);
 413   return T.isLocalRestrictQualified();
 414 }
 415
 416 unsigned clang_getAddressSpace(CXType CT) {
 417   QualType T = GetQualType(CT);
 418
 419   // For non language-specific address space, use separate helper function.
 420   if (T.getAddressSpace() >= LangAS::FirstTargetAddressSpace) {
 421     return T.getQualifiers().getAddressSpaceAttributePrintValue();
 422   }
 423   // FIXME: this function returns either a LangAS or a target AS
 424   // Those values can overlap which makes this function rather unpredictable
 425   // for any caller
 426   return (unsigned)T.getAddressSpace();
 427 }
 428
 429 CXString clang_getTypedefName(CXType CT) {
 430   QualType T = GetQualType(CT);
 431   const TypedefType *TT = T->getAs<TypedefType>();
 432   if (TT) {
 433     TypedefNameDecl *TD = TT->getDecl();
 434     if (TD)
 435       return cxstring::createDup(TD->getNameAsString().c_str());
 436   }
 437   return cxstring::createEmpty();
 438 }
 439
 440 CXType clang_getPointeeType(CXType CT) {
 441   QualType T = GetQualType(CT);
 442   const Type *TP = T.getTypePtrOrNull();
 443
 444   if (!TP)
 445     return MakeCXType(QualType(), GetTU(CT));
 446
 447 try_again:
 448   switch (TP->getTypeClass()) {
 449     case Type::Pointer:
 450       T = cast<PointerType>(TP)->getPointeeType();
 451       break;
 452     case Type::BlockPointer:
 453       T = cast<BlockPointerType>(TP)->getPointeeType();
 454       break;
 455     case Type::LValueReference:
 456     case Type::RValueReference:
 457       T = cast<ReferenceType>(TP)->getPointeeType();
 458       break;
 459     case Type::ObjCObjectPointer:
 460       T = cast<ObjCObjectPointerType>(TP)->getPointeeType();
 461       break;
 462     case Type::MemberPointer:
 463       T = cast<MemberPointerType>(TP)->getPointeeType();
 464       break;
 465     case Type::Auto:
 466     case Type::DeducedTemplateSpecialization:
 467       TP = cast<DeducedType>(TP)->getDeducedType().getTypePtrOrNull();
 468       if (TP)
 469         goto try_again;
 470       break;
 471     default:
 472       T = QualType();
 473       break;
 474   }
 475   return MakeCXType(T, GetTU(CT));
 476 }
 477
 478 CXCursor clang_getTypeDeclaration(CXType CT) {
 479   if (CT.kind == CXType_Invalid)
 480     return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound);
 481
 482   QualType T = GetQualType(CT);
 483   const Type *TP = T.getTypePtrOrNull();
 484
 485   if (!TP)
 486     return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound);
 487
 488   Decl *D = nullptr;
 489
 490 try_again:
 491   switch (TP->getTypeClass()) {
 492   case Type::Typedef:
 493     D = cast<TypedefType>(TP)->getDecl();
 494     break;
 495   case Type::ObjCObject:
 496     D = cast<ObjCObjectType>(TP)->getInterface();
 497     break;
 498   case Type::ObjCInterface:
 499     D = cast<ObjCInterfaceType>(TP)->getDecl();
 500     break;
 501   case Type::Record:
 502   case Type::Enum:
 503     D = cast<TagType>(TP)->getDecl();
 504     break;
 505   case Type::TemplateSpecialization:
 506     if (const RecordType *Record = TP->getAs<RecordType>())
 507       D = Record->getDecl();
 508     else
 509       D = cast<TemplateSpecializationType>(TP)->getTemplateName()
 510                                                          .getAsTemplateDecl();
 511     break;
 512
 513   case Type::Auto:
 514   case Type::DeducedTemplateSpecialization:
 515     TP = cast<DeducedType>(TP)->getDeducedType().getTypePtrOrNull();
 516     if (TP)
 517       goto try_again;
 518     break;
 519
 520   case Type::InjectedClassName:
 521     D = cast<InjectedClassNameType>(TP)->getDecl();
 522     break;
 523
 524   // FIXME: Template type parameters!
 525
 526   case Type::Elaborated:
 527     TP = cast<ElaboratedType>(TP)->getNamedType().getTypePtrOrNull();
 528     goto try_again;
 529
 530   default:
 531     break;
 532   }
 533
 534   if (!D)
 535     return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound);
 536
 537   return cxcursor::MakeCXCursor(D, GetTU(CT));
 538 }
 539
 540 CXString clang_getTypeKindSpelling(enum CXTypeKind K) {
 541   const char *s = nullptr;
 542 #define TKIND(X) case CXType_##X: s = ""  #X  ""; break
 543   switch (K) {
 544     TKIND(Invalid);
 545     TKIND(Unexposed);
 546     TKIND(Void);
 547     TKIND(Bool);
 548     TKIND(Char_U);
 549     TKIND(UChar);
 550     TKIND(Char16);
 551     TKIND(Char32);
 552     TKIND(UShort);
 553     TKIND(UInt);
 554     TKIND(ULong);
 555     TKIND(ULongLong);
 556     TKIND(UInt128);
 557     TKIND(Char_S);
 558     TKIND(SChar);
 559     case CXType_WChar: s = "WChar"; break;
 560     TKIND(Short);
 561     TKIND(Int);
 562     TKIND(Long);
 563     TKIND(LongLong);
 564     TKIND(Int128);
 565     TKIND(Half);
 566     TKIND(Float);
 567     TKIND(Double);
 568     TKIND(LongDouble);
 569     TKIND(ShortAccum);
 570     TKIND(Accum);
 571     TKIND(LongAccum);
 572     TKIND(UShortAccum);
 573     TKIND(UAccum);
 574     TKIND(ULongAccum);
 575     TKIND(Float16);
 576     TKIND(Float128);
 577     TKIND(NullPtr);
 578     TKIND(Overload);
 579     TKIND(Dependent);
 580     TKIND(ObjCId);
 581     TKIND(ObjCClass);
 582     TKIND(ObjCSel);
 583     TKIND(Complex);
 584     TKIND(Pointer);
 585     TKIND(BlockPointer);
 586     TKIND(LValueReference);
 587     TKIND(RValueReference);
 588     TKIND(Record);
 589     TKIND(Enum);
 590     TKIND(Typedef);
 591     TKIND(ObjCInterface);
 592     TKIND(ObjCObject);
 593     TKIND(ObjCObjectPointer);
 594     TKIND(ObjCTypeParam);
 595     TKIND(FunctionNoProto);
 596     TKIND(FunctionProto);
 597     TKIND(ConstantArray);
 598     TKIND(IncompleteArray);
 599     TKIND(VariableArray);
 600     TKIND(DependentSizedArray);
 601     TKIND(Vector);
 602     TKIND(MemberPointer);
 603     TKIND(Auto);
 604     TKIND(Elaborated);
 605     TKIND(Pipe);
 606     TKIND(Attributed);
 607 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) TKIND(Id);
 608 #include "clang/Basic/OpenCLImageTypes.def"
 609 #undef IMAGE_TYPE
 610 #define EXT_OPAQUE_TYPE(ExtTYpe, Id, Ext) TKIND(Id);
 611 #include "clang/Basic/OpenCLExtensionTypes.def"
 612     TKIND(OCLSampler);
 613     TKIND(OCLEvent);
 614     TKIND(OCLQueue);
 615     TKIND(OCLReserveID);
 616   }
 617 #undef TKIND
 618   return cxstring::createRef(s);
 619 }
 620
 621 unsigned clang_equalTypes(CXType A, CXType B) {
 622   return A.data[0] == B.data[0] && A.data[1] == B.data[1];
 623 }
 624
 625 unsigned clang_isFunctionTypeVariadic(CXType X) {
 626   QualType T = GetQualType(X);
 627   if (T.isNull())
 628     return 0;
 629
 630   if (const FunctionProtoType *FD = T->getAs<FunctionProtoType>())
 631     return (unsigned)FD->isVariadic();
 632
 633   if (T->getAs<FunctionNoProtoType>())
 634     return 1;
 635
 636   return 0;
 637 }
 638
 639 CXCallingConv clang_getFunctionTypeCallingConv(CXType X) {
 640   QualType T = GetQualType(X);
 641   if (T.isNull())
 642     return CXCallingConv_Invalid;
 643
 644   if (const FunctionType *FD = T->getAs<FunctionType>()) {
 645 #define TCALLINGCONV(X) case CC_##X: return CXCallingConv_##X
 646     switch (FD->getCallConv()) {
 647       TCALLINGCONV(C);
 648       TCALLINGCONV(X86StdCall);
 649       TCALLINGCONV(X86FastCall);
 650       TCALLINGCONV(X86ThisCall);
 651       TCALLINGCONV(X86Pascal);
 652       TCALLINGCONV(X86RegCall);
 653       TCALLINGCONV(X86VectorCall);
 654       TCALLINGCONV(AArch64VectorCall);
 655       TCALLINGCONV(Win64);
 656       TCALLINGCONV(X86_64SysV);
 657       TCALLINGCONV(AAPCS);
 658       TCALLINGCONV(AAPCS_VFP);
 659       TCALLINGCONV(IntelOclBicc);
 660       TCALLINGCONV(Swift);
 661       TCALLINGCONV(PreserveMost);
 662       TCALLINGCONV(PreserveAll);
 663     case CC_SpirFunction: return CXCallingConv_Unexposed;
 664     case CC_OpenCLKernel: return CXCallingConv_Unexposed;
 665       break;
 666     }
 667 #undef TCALLINGCONV
 668   }
 669
 670   return CXCallingConv_Invalid;
 671 }
 672
 673 int clang_getNumArgTypes(CXType X) {
 674   QualType T = GetQualType(X);
 675   if (T.isNull())
 676     return -1;
 677
 678   if (const FunctionProtoType *FD = T->getAs<FunctionProtoType>()) {
 679     return FD->getNumParams();
 680   }
 681
 682   if (T->getAs<FunctionNoProtoType>()) {
 683     return 0;
 684   }
 685
 686   return -1;
 687 }
 688
 689 CXType clang_getArgType(CXType X, unsigned i) {
 690   QualType T = GetQualType(X);
 691   if (T.isNull())
 692     return MakeCXType(QualType(), GetTU(X));
 693
 694   if (const FunctionProtoType *FD = T->getAs<FunctionProtoType>()) {
 695     unsigned numParams = FD->getNumParams();
 696     if (i >= numParams)
 697       return MakeCXType(QualType(), GetTU(X));
 698
 699     return MakeCXType(FD->getParamType(i), GetTU(X));
 700   }
 701
 702   return MakeCXType(QualType(), GetTU(X));
 703 }
 704
 705 CXType clang_getResultType(CXType X) {
 706   QualType T = GetQualType(X);
 707   if (T.isNull())
 708     return MakeCXType(QualType(), GetTU(X));
 709
 710   if (const FunctionType *FD = T->getAs<FunctionType>())
 711     return MakeCXType(FD->getReturnType(), GetTU(X));
 712
 713   return MakeCXType(QualType(), GetTU(X));
 714 }
 715
 716 CXType clang_getCursorResultType(CXCursor C) {
 717   if (clang_isDeclaration(C.kind)) {
 718     const Decl *D = cxcursor::getCursorDecl(C);
 719     if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D))
 720       return MakeCXType(MD->getReturnType(), cxcursor::getCursorTU(C));
 721
 722     return clang_getResultType(clang_getCursorType(C));
 723   }
 724
 725   return MakeCXType(QualType(), cxcursor::getCursorTU(C));
 726 }
 727
 728 // FIXME: We should expose the canThrow(...) result instead of the EST.
 729 static CXCursor_ExceptionSpecificationKind
 730 getExternalExceptionSpecificationKind(ExceptionSpecificationType EST) {
 731   switch (EST) {
 732   case EST_None:
 733     return CXCursor_ExceptionSpecificationKind_None;
 734   case EST_DynamicNone:
 735     return CXCursor_ExceptionSpecificationKind_DynamicNone;
 736   case EST_Dynamic:
 737     return CXCursor_ExceptionSpecificationKind_Dynamic;
 738   case EST_MSAny:
 739     return CXCursor_ExceptionSpecificationKind_MSAny;
 740   case EST_BasicNoexcept:
 741     return CXCursor_ExceptionSpecificationKind_BasicNoexcept;
 742   case EST_NoexceptFalse:
 743   case EST_NoexceptTrue:
 744   case EST_DependentNoexcept:
 745     return CXCursor_ExceptionSpecificationKind_ComputedNoexcept;
 746   case EST_Unevaluated:
 747     return CXCursor_ExceptionSpecificationKind_Unevaluated;
 748   case EST_Uninstantiated:
 749     return CXCursor_ExceptionSpecificationKind_Uninstantiated;
 750   case EST_Unparsed:
 751     return CXCursor_ExceptionSpecificationKind_Unparsed;
 752   }
 753   llvm_unreachable("invalid EST value");
 754 }
 755
 756 int clang_getExceptionSpecificationType(CXType X) {
 757   QualType T = GetQualType(X);
 758   if (T.isNull())
 759     return -1;
 760
 761   if (const auto *FD = T->getAs<FunctionProtoType>())
 762     return getExternalExceptionSpecificationKind(FD->getExceptionSpecType());
 763
 764   return -1;
 765 }
 766
 767 int clang_getCursorExceptionSpecificationType(CXCursor C) {
 768   if (clang_isDeclaration(C.kind))
 769     return clang_getExceptionSpecificationType(clang_getCursorType(C));
 770
 771   return -1;
 772 }
 773
 774 unsigned clang_isPODType(CXType X) {
 775   QualType T = GetQualType(X);
 776   if (T.isNull())
 777     return 0;
 778
 779   CXTranslationUnit TU = GetTU(X);
 780
 781   return T.isPODType(cxtu::getASTUnit(TU)->getASTContext()) ? 1 : 0;
 782 }
 783
 784 CXType clang_getElementType(CXType CT) {
 785   QualType ET = QualType();
 786   QualType T = GetQualType(CT);
 787   const Type *TP = T.getTypePtrOrNull();
 788
 789   if (TP) {
 790     switch (TP->getTypeClass()) {
 791     case Type::ConstantArray:
 792       ET = cast<ConstantArrayType> (TP)->getElementType();
 793       break;
 794     case Type::IncompleteArray:
 795       ET = cast<IncompleteArrayType> (TP)->getElementType();
 796       break;
 797     case Type::VariableArray:
 798       ET = cast<VariableArrayType> (TP)->getElementType();
 799       break;
 800     case Type::DependentSizedArray:
 801       ET = cast<DependentSizedArrayType> (TP)->getElementType();
 802       break;
 803     case Type::Vector:
 804       ET = cast<VectorType> (TP)->getElementType();
 805       break;
 806     case Type::Complex:
 807       ET = cast<ComplexType> (TP)->getElementType();
 808       break;
 809     default:
 810       break;
 811     }
 812   }
 813   return MakeCXType(ET, GetTU(CT));
 814 }
 815
 816 long long clang_getNumElements(CXType CT) {
 817   long long result = -1;
 818   QualType T = GetQualType(CT);
 819   const Type *TP = T.getTypePtrOrNull();
 820
 821   if (TP) {
 822     switch (TP->getTypeClass()) {
 823     case Type::ConstantArray:
 824       result = cast<ConstantArrayType> (TP)->getSize().getSExtValue();
 825       break;
 826     case Type::Vector:
 827       result = cast<VectorType> (TP)->getNumElements();
 828       break;
 829     default:
 830       break;
 831     }
 832   }
 833   return result;
 834 }
 835
 836 CXType clang_getArrayElementType(CXType CT) {
 837   QualType ET = QualType();
 838   QualType T = GetQualType(CT);
 839   const Type *TP = T.getTypePtrOrNull();
 840
 841   if (TP) {
 842     switch (TP->getTypeClass()) {
 843     case Type::ConstantArray:
 844       ET = cast<ConstantArrayType> (TP)->getElementType();
 845       break;
 846     case Type::IncompleteArray:
 847       ET = cast<IncompleteArrayType> (TP)->getElementType();
 848       break;
 849     case Type::VariableArray:
 850       ET = cast<VariableArrayType> (TP)->getElementType();
 851       break;
 852     case Type::DependentSizedArray:
 853       ET = cast<DependentSizedArrayType> (TP)->getElementType();
 854       break;
 855     default:
 856       break;
 857     }
 858   }
 859   return MakeCXType(ET, GetTU(CT));
 860 }
 861
 862 long long clang_getArraySize(CXType CT) {
 863   long long result = -1;
 864   QualType T = GetQualType(CT);
 865   const Type *TP = T.getTypePtrOrNull();
 866
 867   if (TP) {
 868     switch (TP->getTypeClass()) {
 869     case Type::ConstantArray:
 870       result = cast<ConstantArrayType> (TP)->getSize().getSExtValue();
 871       break;
 872     default:
 873       break;
 874     }
 875   }
 876   return result;
 877 }
 878
 879 long long clang_Type_getAlignOf(CXType T) {
 880   if (T.kind == CXType_Invalid)
 881     return CXTypeLayoutError_Invalid;
 882   ASTContext &Ctx = cxtu::getASTUnit(GetTU(T))->getASTContext();
 883   QualType QT = GetQualType(T);
 884   // [expr.alignof] p1: return size_t value for complete object type, reference
 885   //                    or array.
 886   // [expr.alignof] p3: if reference type, return size of referenced type
 887   if (QT->isReferenceType())
 888     QT = QT.getNonReferenceType();
 889   if (QT->isIncompleteType())
 890     return CXTypeLayoutError_Incomplete;
 891   if (QT->isDependentType())
 892     return CXTypeLayoutError_Dependent;
 893   // Exceptions by GCC extension - see ASTContext.cpp:1313 getTypeInfoImpl
 894   // if (QT->isFunctionType()) return 4; // Bug #15511 - should be 1
 895   // if (QT->isVoidType()) return 1;
 896   return Ctx.getTypeAlignInChars(QT).getQuantity();
 897 }
 898
 899 CXType clang_Type_getClassType(CXType CT) {
 900   QualType ET = QualType();
 901   QualType T = GetQualType(CT);
 902   const Type *TP = T.getTypePtrOrNull();
 903
 904   if (TP && TP->getTypeClass() == Type::MemberPointer) {
 905     ET = QualType(cast<MemberPointerType> (TP)->getClass(), 0);
 906   }
 907   return MakeCXType(ET, GetTU(CT));
 908 }
 909
 910 long long clang_Type_getSizeOf(CXType T) {
 911   if (T.kind == CXType_Invalid)
 912     return CXTypeLayoutError_Invalid;
 913   ASTContext &Ctx = cxtu::getASTUnit(GetTU(T))->getASTContext();
 914   QualType QT = GetQualType(T);
 915   // [expr.sizeof] p2: if reference type, return size of referenced type
 916   if (QT->isReferenceType())
 917     QT = QT.getNonReferenceType();
 918   // [expr.sizeof] p1: return -1 on: func, incomplete, bitfield, incomplete
 919   //                   enumeration
 920   // Note: We get the cxtype, not the cxcursor, so we can't call
 921   //       FieldDecl->isBitField()
 922   // [expr.sizeof] p3: pointer ok, function not ok.
 923   // [gcc extension] lib/AST/ExprConstant.cpp:1372 HandleSizeof : vla == error
 924   if (QT->isIncompleteType())
 925     return CXTypeLayoutError_Incomplete;
 926   if (QT->isDependentType())
 927     return CXTypeLayoutError_Dependent;
 928   if (!QT->isConstantSizeType())
 929     return CXTypeLayoutError_NotConstantSize;
 930   // [gcc extension] lib/AST/ExprConstant.cpp:1372
 931   //                 HandleSizeof : {voidtype,functype} == 1
 932   // not handled by ASTContext.cpp:1313 getTypeInfoImpl
 933   if (QT->isVoidType() || QT->isFunctionType())
 934     return 1;
 935   return Ctx.getTypeSizeInChars(QT).getQuantity();
 936 }
 937
 938 static long long visitRecordForValidation(const RecordDecl *RD) {
 939   for (const auto *I : RD->fields()){
 940     QualType FQT = I->getType();
 941     if (FQT->isIncompleteType())
 942       return CXTypeLayoutError_Incomplete;
 943     if (FQT->isDependentType())
 944       return CXTypeLayoutError_Dependent;
 945     // recurse
 946     if (const RecordType *ChildType = I->getType()->getAs<RecordType>()) {
 947       if (const RecordDecl *Child = ChildType->getDecl()) {
 948         long long ret = visitRecordForValidation(Child);
 949         if (ret < 0)
 950           return ret;
 951       }
 952     }
 953     // else try next field
 954   }
 955   return 0;
 956 }
 957
 958 static long long validateFieldParentType(CXCursor PC, CXType PT){
 959   if (clang_isInvalid(PC.kind))
 960     return CXTypeLayoutError_Invalid;
 961   const RecordDecl *RD =
 962         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
 963   // validate parent declaration
 964   if (!RD || RD->isInvalidDecl())
 965     return CXTypeLayoutError_Invalid;
 966   RD = RD->getDefinition();
 967   if (!RD)
 968     return CXTypeLayoutError_Incomplete;
 969   if (RD->isInvalidDecl())
 970     return CXTypeLayoutError_Invalid;
 971   // validate parent type
 972   QualType RT = GetQualType(PT);
 973   if (RT->isIncompleteType())
 974     return CXTypeLayoutError_Incomplete;
 975   if (RT->isDependentType())
 976     return CXTypeLayoutError_Dependent;
 977   // We recurse into all record fields to detect incomplete and dependent types.
 978   long long Error = visitRecordForValidation(RD);
 979   if (Error < 0)
 980     return Error;
 981   return 0;
 982 }
 983
 984 long long clang_Type_getOffsetOf(CXType PT, const char *S) {
 985   // check that PT is not incomplete/dependent
 986   CXCursor PC = clang_getTypeDeclaration(PT);
 987   long long Error = validateFieldParentType(PC,PT);
 988   if (Error < 0)
 989     return Error;
 990   if (!S)
 991     return CXTypeLayoutError_InvalidFieldName;
 992   // lookup field
 993   ASTContext &Ctx = cxtu::getASTUnit(GetTU(PT))->getASTContext();
 994   IdentifierInfo *II = &Ctx.Idents.get(S);
 995   DeclarationName FieldName(II);
 996   const RecordDecl *RD =
 997         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
 998   // verified in validateFieldParentType
 999   RD = RD->getDefinition();
1000   RecordDecl::lookup_result Res = RD->lookup(FieldName);
1001   // If a field of the parent record is incomplete, lookup will fail.
1002   // and we would return InvalidFieldName instead of Incomplete.
1003   // But this erroneous results does protects again a hidden assertion failure
1004   // in the RecordLayoutBuilder
1005   if (Res.size() != 1)
1006     return CXTypeLayoutError_InvalidFieldName;
1007   if (const FieldDecl *FD = dyn_cast<FieldDecl>(Res.front()))
1008     return Ctx.getFieldOffset(FD);
1009   if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(Res.front()))
1010     return Ctx.getFieldOffset(IFD);
1011   // we don't want any other Decl Type.
1012   return CXTypeLayoutError_InvalidFieldName;
1013 }
1014
1015 CXType clang_Type_getModifiedType(CXType CT) {
1016   QualType T = GetQualType(CT);
1017   if (T.isNull())
1018     return MakeCXType(QualType(), GetTU(CT));
1019
1020   if (auto *ATT = T->getAs<AttributedType>())
1021     return MakeCXType(ATT->getModifiedType(), GetTU(CT));
1022
1023   return MakeCXType(QualType(), GetTU(CT));
1024 }
1025
1026 long long clang_Cursor_getOffsetOfField(CXCursor C) {
1027   if (clang_isDeclaration(C.kind)) {
1028     // we need to validate the parent type
1029     CXCursor PC = clang_getCursorSemanticParent(C);
1030     CXType PT = clang_getCursorType(PC);
1031     long long Error = validateFieldParentType(PC,PT);
1032     if (Error < 0)
1033       return Error;
1034     // proceed with the offset calculation
1035     const Decl *D = cxcursor::getCursorDecl(C);
1036     ASTContext &Ctx = cxcursor::getCursorContext(C);
1037     if (const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D))
1038       return Ctx.getFieldOffset(FD);
1039     if (const IndirectFieldDecl *IFD = dyn_cast_or_null<IndirectFieldDecl>(D))
1040       return Ctx.getFieldOffset(IFD);
1041   }
1042   return -1;
1043 }
1044
1045 enum CXRefQualifierKind clang_Type_getCXXRefQualifier(CXType T) {
1046   QualType QT = GetQualType(T);
1047   if (QT.isNull())
1048     return CXRefQualifier_None;
1049   const FunctionProtoType *FD = QT->getAs<FunctionProtoType>();
1050   if (!FD)
1051     return CXRefQualifier_None;
1052   switch (FD->getRefQualifier()) {
1053     case RQ_None:
1054       return CXRefQualifier_None;
1055     case RQ_LValue:
1056       return CXRefQualifier_LValue;
1057     case RQ_RValue:
1058       return CXRefQualifier_RValue;
1059   }
1060   return CXRefQualifier_None;
1061 }
1062
1063 unsigned clang_Cursor_isBitField(CXCursor C) {
1064   if (!clang_isDeclaration(C.kind))
1065     return 0;
1066   const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(cxcursor::getCursorDecl(C));
1067   if (!FD)
1068     return 0;
1069   return FD->isBitField();
1070 }
1071
1072 CXString clang_getDeclObjCTypeEncoding(CXCursor C) {
1073   if (!clang_isDeclaration(C.kind))
1074     return cxstring::createEmpty();
1075
1076   const Decl *D = cxcursor::getCursorDecl(C);
1077   ASTContext &Ctx = cxcursor::getCursorContext(C);
1078   std::string encoding;
1079
1080   if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D))  {
1081     encoding = Ctx.getObjCEncodingForMethodDecl(OMD);
1082   } else if (const ObjCPropertyDecl *OPD = dyn_cast<ObjCPropertyDecl>(D))
1083     encoding = Ctx.getObjCEncodingForPropertyDecl(OPD, nullptr);
1084   else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
1085     encoding = Ctx.getObjCEncodingForFunctionDecl(FD);
1086   else {
1087     QualType Ty;
1088     if (const TypeDecl *TD = dyn_cast<TypeDecl>(D))
1089       Ty = Ctx.getTypeDeclType(TD);
1090     if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
1091       Ty = VD->getType();
1092     else return cxstring::createRef("?");
1093     Ctx.getObjCEncodingForType(Ty, encoding);
1094   }
1095
1096   return cxstring::createDup(encoding);
1097 }
1098
1099 static unsigned GetTemplateArgumentArraySize(ArrayRef<TemplateArgument> TA) {
1100   unsigned size = TA.size();
1101   for (const auto &Arg : TA)
1102     if (Arg.getKind() == TemplateArgument::Pack)
1103       size += Arg.pack_size() - 1;
1104   return size;
1105 }
1106
1107 int clang_Type_getNumTemplateArguments(CXType CT) {
1108   QualType T = GetQualType(CT);
1109   if (T.isNull())
1110     return -1;
1111
1112   auto TA = GetTemplateArguments(T);
1113   if (!TA)
1114     return -1;
1115
1116   return GetTemplateArgumentArraySize(TA.getValue());
1117 }
1118
1119 CXType clang_Type_getTemplateArgumentAsType(CXType CT, unsigned index) {
1120   QualType T = GetQualType(CT);
1121   if (T.isNull())
1122     return MakeCXType(QualType(), GetTU(CT));
1123
1124   auto TA = GetTemplateArguments(T);
1125   if (!TA)
1126     return MakeCXType(QualType(), GetTU(CT));
1127
1128   Optional<QualType> QT = FindTemplateArgumentTypeAt(TA.getValue(), index);
1129   return MakeCXType(QT.getValueOr(QualType()), GetTU(CT));
1130 }
1131
1132 CXType clang_Type_getObjCObjectBaseType(CXType CT) {
1133   QualType T = GetQualType(CT);
1134   if (T.isNull())
1135     return MakeCXType(QualType(), GetTU(CT));
1136
1137   const ObjCObjectType *OT = dyn_cast<ObjCObjectType>(T);
1138   if (!OT)
1139     return MakeCXType(QualType(), GetTU(CT));
1140
1141   return MakeCXType(OT->getBaseType(), GetTU(CT));
1142 }
1143
1144 unsigned clang_Type_getNumObjCProtocolRefs(CXType CT) {
1145   QualType T = GetQualType(CT);
1146   if (T.isNull())
1147     return 0;
1148
1149   const ObjCObjectType *OT = dyn_cast<ObjCObjectType>(T);
1150   if (!OT)
1151     return 0;
1152
1153   return OT->getNumProtocols();
1154 }
1155
1156 CXCursor clang_Type_getObjCProtocolDecl(CXType CT, unsigned i) {
1157   QualType T = GetQualType(CT);
1158   if (T.isNull())
1159     return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound);
1160
1161   const ObjCObjectType *OT = dyn_cast<ObjCObjectType>(T);
1162   if (!OT)
1163     return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound);
1164
1165   const ObjCProtocolDecl *PD = OT->getProtocol(i);
1166   if (!PD)
1167     return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound);
1168
1169   return cxcursor::MakeCXCursor(PD, GetTU(CT));
1170 }
1171
1172 unsigned clang_Type_getNumObjCTypeArgs(CXType CT) {
1173   QualType T = GetQualType(CT);
1174   if (T.isNull())
1175     return 0;
1176
1177   const ObjCObjectType *OT = dyn_cast<ObjCObjectType>(T);
1178   if (!OT)
1179     return 0;
1180
1181   return OT->getTypeArgs().size();
1182 }
1183
1184 CXType clang_Type_getObjCTypeArg(CXType CT, unsigned i) {
1185   QualType T = GetQualType(CT);
1186   if (T.isNull())
1187     return MakeCXType(QualType(), GetTU(CT));
1188
1189   const ObjCObjectType *OT = dyn_cast<ObjCObjectType>(T);
1190   if (!OT)
1191     return MakeCXType(QualType(), GetTU(CT));
1192
1193   const ArrayRef<QualType> TA = OT->getTypeArgs();
1194   if ((size_t)i >= TA.size())
1195     return MakeCXType(QualType(), GetTU(CT));
1196
1197   return MakeCXType(TA[i], GetTU(CT));
1198 }
1199
1200 unsigned clang_Type_visitFields(CXType PT,
1201                                 CXFieldVisitor visitor,
1202                                 CXClientData client_data){
1203   CXCursor PC = clang_getTypeDeclaration(PT);
1204   if (clang_isInvalid(PC.kind))
1205     return false;
1206   const RecordDecl *RD =
1207         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
1208   if (!RD || RD->isInvalidDecl())
1209     return false;
1210   RD = RD->getDefinition();
1211   if (!RD || RD->isInvalidDecl())
1212     return false;
1213
1214   for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
1215        I != E; ++I){
1216     const FieldDecl *FD = dyn_cast_or_null<FieldDecl>((*I));
1217     // Callback to the client.
1218     switch (visitor(cxcursor::MakeCXCursor(FD, GetTU(PT)), client_data)){
1219     case CXVisit_Break:
1220       return true;
1221     case CXVisit_Continue:
1222       break;
1223     }
1224   }
1225   return true;
1226 }
1227
1228 unsigned clang_Cursor_isAnonymous(CXCursor C){
1229   if (!clang_isDeclaration(C.kind))
1230     return 0;
1231   const Decl *D = cxcursor::getCursorDecl(C);
1232   if (const NamespaceDecl *ND = dyn_cast_or_null<NamespaceDecl>(D)) {
1233     return ND->isAnonymousNamespace();
1234   } else if (const TagDecl *TD = dyn_cast_or_null<TagDecl>(D)) {
1235     return TD->getTypedefNameForAnonDecl() == nullptr &&
1236            TD->getIdentifier() == nullptr;
1237   }
1238
1239   return 0;
1240 }
1241 CXType clang_Type_getNamedType(CXType CT){
1242   QualType T = GetQualType(CT);
1243   const Type *TP = T.getTypePtrOrNull();
1244
1245   if (TP && TP->getTypeClass() == Type::Elaborated)
1246     return MakeCXType(cast<ElaboratedType>(TP)->getNamedType(), GetTU(CT));
1247
1248   return MakeCXType(QualType(), GetTU(CT));
1249 }
1250
1251 unsigned clang_Type_isTransparentTagTypedef(CXType TT){
1252   QualType T = GetQualType(TT);
1253   if (auto *TT = dyn_cast_or_null<TypedefType>(T.getTypePtrOrNull())) {
1254     if (auto *D = TT->getDecl())
1255       return D->isTransparentTag();
1256   }
1257   return false;
1258 }
1259
1260 enum CXTypeNullabilityKind clang_Type_getNullability(CXType CT) {
1261   QualType T = GetQualType(CT);
1262   if (T.isNull())
1263     return CXTypeNullability_Invalid;
1264
1265   ASTContext &Ctx = cxtu::getASTUnit(GetTU(CT))->getASTContext();
1266   if (auto nullability = T->getNullability(Ctx)) {
1267     switch (*nullability) {
1268       case NullabilityKind::NonNull:
1269         return CXTypeNullability_NonNull;
1270       case NullabilityKind::Nullable:
1271         return CXTypeNullability_Nullable;
1272       case NullabilityKind::Unspecified:
1273         return CXTypeNullability_Unspecified;
1274     }
1275   }
1276   return CXTypeNullability_Invalid;
1277 }