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