clang/tools/libclang/CXType.cpp

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