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