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