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