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