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