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