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