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(Win64);
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 }
1107