Clang Project

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