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