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