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