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 unsigned clang_isPODType(CXType X) {
688   QualType T = GetQualType(X);
689   if (T.isNull())
690     return 0;
691 
692   CXTranslationUnit TU = GetTU(X);
693 
694   return T.isPODType(cxtu::getASTUnit(TU)->getASTContext()) ? 1 : 0;
695 }
696 
697 CXType clang_getElementType(CXType CT) {
698   QualType ET = QualType();
699   QualType T = GetQualType(CT);
700   const Type *TP = T.getTypePtrOrNull();
701 
702   if (TP) {
703     switch (TP->getTypeClass()) {
704     case Type::ConstantArray:
705       ET = cast<ConstantArrayType> (TP)->getElementType();
706       break;
707     case Type::IncompleteArray:
708       ET = cast<IncompleteArrayType> (TP)->getElementType();
709       break;
710     case Type::VariableArray:
711       ET = cast<VariableArrayType> (TP)->getElementType();
712       break;
713     case Type::DependentSizedArray:
714       ET = cast<DependentSizedArrayType> (TP)->getElementType();
715       break;
716     case Type::Vector:
717       ET = cast<VectorType> (TP)->getElementType();
718       break;
719     case Type::Complex:
720       ET = cast<ComplexType> (TP)->getElementType();
721       break;
722     default:
723       break;
724     }
725   }
726   return MakeCXType(ET, GetTU(CT));
727 }
728 
729 long long clang_getNumElements(CXType CT) {
730   long long result = -1;
731   QualType T = GetQualType(CT);
732   const Type *TP = T.getTypePtrOrNull();
733 
734   if (TP) {
735     switch (TP->getTypeClass()) {
736     case Type::ConstantArray:
737       result = cast<ConstantArrayType> (TP)->getSize().getSExtValue();
738       break;
739     case Type::Vector:
740       result = cast<VectorType> (TP)->getNumElements();
741       break;
742     default:
743       break;
744     }
745   }
746   return result;
747 }
748 
749 CXType clang_getArrayElementType(CXType CT) {
750   QualType ET = QualType();
751   QualType T = GetQualType(CT);
752   const Type *TP = T.getTypePtrOrNull();
753 
754   if (TP) {
755     switch (TP->getTypeClass()) {
756     case Type::ConstantArray:
757       ET = cast<ConstantArrayType> (TP)->getElementType();
758       break;
759     case Type::IncompleteArray:
760       ET = cast<IncompleteArrayType> (TP)->getElementType();
761       break;
762     case Type::VariableArray:
763       ET = cast<VariableArrayType> (TP)->getElementType();
764       break;
765     case Type::DependentSizedArray:
766       ET = cast<DependentSizedArrayType> (TP)->getElementType();
767       break;
768     default:
769       break;
770     }
771   }
772   return MakeCXType(ET, GetTU(CT));
773 }
774 
775 long long clang_getArraySize(CXType CT) {
776   long long result = -1;
777   QualType T = GetQualType(CT);
778   const Type *TP = T.getTypePtrOrNull();
779 
780   if (TP) {
781     switch (TP->getTypeClass()) {
782     case Type::ConstantArray:
783       result = cast<ConstantArrayType> (TP)->getSize().getSExtValue();
784       break;
785     default:
786       break;
787     }
788   }
789   return result;
790 }
791 
792 long long clang_Type_getAlignOf(CXType T) {
793   if (T.kind == CXType_Invalid)
794     return CXTypeLayoutError_Invalid;
795   ASTContext &Ctx = cxtu::getASTUnit(GetTU(T))->getASTContext();
796   QualType QT = GetQualType(T);
797   // [expr.alignof] p1: return size_t value for complete object type, reference
798   //                    or array.
799   // [expr.alignof] p3: if reference type, return size of referenced type
800   if (QT->isReferenceType())
801     QT = QT.getNonReferenceType();
802   if (QT->isIncompleteType())
803     return CXTypeLayoutError_Incomplete;
804   if (QT->isDependentType())
805     return CXTypeLayoutError_Dependent;
806   // Exceptions by GCC extension - see ASTContext.cpp:1313 getTypeInfoImpl
807   // if (QT->isFunctionType()) return 4; // Bug #15511 - should be 1
808   // if (QT->isVoidType()) return 1;
809   return Ctx.getTypeAlignInChars(QT).getQuantity();
810 }
811 
812 CXType clang_Type_getClassType(CXType CT) {
813   QualType ET = QualType();
814   QualType T = GetQualType(CT);
815   const Type *TP = T.getTypePtrOrNull();
816 
817   if (TP && TP->getTypeClass() == Type::MemberPointer) {
818     ET = QualType(cast<MemberPointerType> (TP)->getClass(), 0);
819   }
820   return MakeCXType(ET, GetTU(CT));
821 }
822 
823 long long clang_Type_getSizeOf(CXType T) {
824   if (T.kind == CXType_Invalid)
825     return CXTypeLayoutError_Invalid;
826   ASTContext &Ctx = cxtu::getASTUnit(GetTU(T))->getASTContext();
827   QualType QT = GetQualType(T);
828   // [expr.sizeof] p2: if reference type, return size of referenced type
829   if (QT->isReferenceType())
830     QT = QT.getNonReferenceType();
831   // [expr.sizeof] p1: return -1 on: func, incomplete, bitfield, incomplete
832   //                   enumeration
833   // Note: We get the cxtype, not the cxcursor, so we can't call
834   //       FieldDecl->isBitField()
835   // [expr.sizeof] p3: pointer ok, function not ok.
836   // [gcc extension] lib/AST/ExprConstant.cpp:1372 HandleSizeof : vla == error
837   if (QT->isIncompleteType())
838     return CXTypeLayoutError_Incomplete;
839   if (QT->isDependentType())
840     return CXTypeLayoutError_Dependent;
841   if (!QT->isConstantSizeType())
842     return CXTypeLayoutError_NotConstantSize;
843   // [gcc extension] lib/AST/ExprConstant.cpp:1372
844   //                 HandleSizeof : {voidtype,functype} == 1
845   // not handled by ASTContext.cpp:1313 getTypeInfoImpl
846   if (QT->isVoidType() || QT->isFunctionType())
847     return 1;
848   return Ctx.getTypeSizeInChars(QT).getQuantity();
849 }
850 
851 static long long visitRecordForValidation(const RecordDecl *RD) {
852   for (const auto *I : RD->fields()){
853     QualType FQT = I->getType();
854     if (FQT->isIncompleteType())
855       return CXTypeLayoutError_Incomplete;
856     if (FQT->isDependentType())
857       return CXTypeLayoutError_Dependent;
858     // recurse
859     if (const RecordType *ChildType = I->getType()->getAs<RecordType>()) {
860       if (const RecordDecl *Child = ChildType->getDecl()) {
861         long long ret = visitRecordForValidation(Child);
862         if (ret < 0)
863           return ret;
864       }
865     }
866     // else try next field
867   }
868   return 0;
869 }
870 
871 static long long validateFieldParentType(CXCursor PC, CXType PT){
872   if (clang_isInvalid(PC.kind))
873     return CXTypeLayoutError_Invalid;
874   const RecordDecl *RD =
875         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
876   // validate parent declaration
877   if (!RD || RD->isInvalidDecl())
878     return CXTypeLayoutError_Invalid;
879   RD = RD->getDefinition();
880   if (!RD)
881     return CXTypeLayoutError_Incomplete;
882   if (RD->isInvalidDecl())
883     return CXTypeLayoutError_Invalid;
884   // validate parent type
885   QualType RT = GetQualType(PT);
886   if (RT->isIncompleteType())
887     return CXTypeLayoutError_Incomplete;
888   if (RT->isDependentType())
889     return CXTypeLayoutError_Dependent;
890   // We recurse into all record fields to detect incomplete and dependent types.
891   long long Error = visitRecordForValidation(RD);
892   if (Error < 0)
893     return Error;
894   return 0;
895 }
896 
897 long long clang_Type_getOffsetOf(CXType PT, const char *S) {
898   // check that PT is not incomplete/dependent
899   CXCursor PC = clang_getTypeDeclaration(PT);
900   long long Error = validateFieldParentType(PC,PT);
901   if (Error < 0)
902     return Error;
903   if (!S)
904     return CXTypeLayoutError_InvalidFieldName;
905   // lookup field
906   ASTContext &Ctx = cxtu::getASTUnit(GetTU(PT))->getASTContext();
907   IdentifierInfo *II = &Ctx.Idents.get(S);
908   DeclarationName FieldName(II);
909   const RecordDecl *RD =
910         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
911   // verified in validateFieldParentType
912   RD = RD->getDefinition();
913   RecordDecl::lookup_result Res = RD->lookup(FieldName);
914   // If a field of the parent record is incomplete, lookup will fail.
915   // and we would return InvalidFieldName instead of Incomplete.
916   // But this erroneous results does protects again a hidden assertion failure
917   // in the RecordLayoutBuilder
918   if (Res.size() != 1)
919     return CXTypeLayoutError_InvalidFieldName;
920   if (const FieldDecl *FD = dyn_cast<FieldDecl>(Res.front()))
921     return Ctx.getFieldOffset(FD);
922   if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(Res.front()))
923     return Ctx.getFieldOffset(IFD);
924   // we don't want any other Decl Type.
925   return CXTypeLayoutError_InvalidFieldName;
926 }
927 
928 long long clang_Cursor_getOffsetOfField(CXCursor C) {
929   if (clang_isDeclaration(C.kind)) {
930     // we need to validate the parent type
931     CXCursor PC = clang_getCursorSemanticParent(C);
932     CXType PT = clang_getCursorType(PC);
933     long long Error = validateFieldParentType(PC,PT);
934     if (Error < 0)
935       return Error;
936     // proceed with the offset calculation
937     const Decl *D = cxcursor::getCursorDecl(C);
938     ASTContext &Ctx = cxcursor::getCursorContext(C);
939     if (const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D))
940       return Ctx.getFieldOffset(FD);
941     if (const IndirectFieldDecl *IFD = dyn_cast_or_null<IndirectFieldDecl>(D))
942       return Ctx.getFieldOffset(IFD);
943   }
944   return -1;
945 }
946 
947 enum CXRefQualifierKind clang_Type_getCXXRefQualifier(CXType T) {
948   QualType QT = GetQualType(T);
949   if (QT.isNull())
950     return CXRefQualifier_None;
951   const FunctionProtoType *FD = QT->getAs<FunctionProtoType>();
952   if (!FD)
953     return CXRefQualifier_None;
954   switch (FD->getRefQualifier()) {
955     case RQ_None:
956       return CXRefQualifier_None;
957     case RQ_LValue:
958       return CXRefQualifier_LValue;
959     case RQ_RValue:
960       return CXRefQualifier_RValue;
961   }
962   return CXRefQualifier_None;
963 }
964 
965 unsigned clang_Cursor_isBitField(CXCursor C) {
966   if (!clang_isDeclaration(C.kind))
967     return 0;
968   const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(cxcursor::getCursorDecl(C));
969   if (!FD)
970     return 0;
971   return FD->isBitField();
972 }
973 
974 CXString clang_getDeclObjCTypeEncoding(CXCursor C) {
975   if (!clang_isDeclaration(C.kind))
976     return cxstring::createEmpty();
977 
978   const Decl *D = cxcursor::getCursorDecl(C);
979   ASTContext &Ctx = cxcursor::getCursorContext(C);
980   std::string encoding;
981 
982   if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D))  {
983     encoding = Ctx.getObjCEncodingForMethodDecl(OMD);
984   } else if (const ObjCPropertyDecl *OPD = dyn_cast<ObjCPropertyDecl>(D))
985     encoding = Ctx.getObjCEncodingForPropertyDecl(OPD, nullptr);
986   else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
987     encoding = Ctx.getObjCEncodingForFunctionDecl(FD);
988   else {
989     QualType Ty;
990     if (const TypeDecl *TD = dyn_cast<TypeDecl>(D))
991       Ty = Ctx.getTypeDeclType(TD);
992     if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
993       Ty = VD->getType();
994     else return cxstring::createRef("?");
995     Ctx.getObjCEncodingForType(Ty, encoding);
996   }
997 
998   return cxstring::createDup(encoding);
999 }
1000 
1001 static unsigned GetTemplateArgumentArraySize(ArrayRef<TemplateArgument> TA) {
1002   unsigned size = TA.size();
1003   for (const auto &Arg : TA)
1004     if (Arg.getKind() == TemplateArgument::Pack)
1005       size += Arg.pack_size() - 1;
1006   return size;
1007 }
1008 
1009 int clang_Type_getNumTemplateArguments(CXType CT) {
1010   QualType T = GetQualType(CT);
1011   if (T.isNull())
1012     return -1;
1013 
1014   auto TA = GetTemplateArguments(T);
1015   if (!TA)
1016     return -1;
1017 
1018   return GetTemplateArgumentArraySize(TA.getValue());
1019 }
1020 
1021 CXType clang_Type_getTemplateArgumentAsType(CXType CT, unsigned index) {
1022   QualType T = GetQualType(CT);
1023   if (T.isNull())
1024     return MakeCXType(QualType(), GetTU(CT));
1025 
1026   auto TA = GetTemplateArguments(T);
1027   if (!TA)
1028     return MakeCXType(QualType(), GetTU(CT));
1029 
1030   Optional<QualType> QT = FindTemplateArgumentTypeAt(TA.getValue(), index);
1031   return MakeCXType(QT.getValueOr(QualType()), GetTU(CT));
1032 }
1033 
1034 unsigned clang_Type_visitFields(CXType PT,
1035                                 CXFieldVisitor visitor,
1036                                 CXClientData client_data){
1037   CXCursor PC = clang_getTypeDeclaration(PT);
1038   if (clang_isInvalid(PC.kind))
1039     return false;
1040   const RecordDecl *RD =
1041         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
1042   if (!RD || RD->isInvalidDecl())
1043     return false;
1044   RD = RD->getDefinition();
1045   if (!RD || RD->isInvalidDecl())
1046     return false;
1047 
1048   for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
1049        I != E; ++I){
1050     const FieldDecl *FD = dyn_cast_or_null<FieldDecl>((*I));
1051     // Callback to the client.
1052     switch (visitor(cxcursor::MakeCXCursor(FD, GetTU(PT)), client_data)){
1053     case CXVisit_Break:
1054       return true;
1055     case CXVisit_Continue:
1056       break;
1057     }
1058   }
1059   return true;
1060 }
1061 
1062 unsigned clang_Cursor_isAnonymous(CXCursor C){
1063   if (!clang_isDeclaration(C.kind))
1064     return 0;
1065   const Decl *D = cxcursor::getCursorDecl(C);
1066   if (const RecordDecl *FD = dyn_cast_or_null<RecordDecl>(D))
1067     return FD->isAnonymousStructOrUnion();
1068   return 0;
1069 }
1070 
1071 CXType clang_Type_getNamedType(CXType CT){
1072   QualType T = GetQualType(CT);
1073   const Type *TP = T.getTypePtrOrNull();
1074 
1075   if (TP && TP->getTypeClass() == Type::Elaborated)
1076     return MakeCXType(cast<ElaboratedType>(TP)->getNamedType(), GetTU(CT));
1077 
1078   return MakeCXType(QualType(), GetTU(CT));
1079 }
1080 
1081 unsigned clang_Type_isTransparentTagTypedef(CXType TT){
1082   QualType T = GetQualType(TT);
1083   if (auto *TT = dyn_cast_or_null<TypedefType>(T.getTypePtrOrNull())) {
1084     if (auto *D = TT->getDecl())
1085       return D->isTransparentTag();
1086   }
1087   return false;
1088 }
1089