1 //===- Type.cpp - Type representation and manipulation --------------------===//
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 type-related functionality.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/AST/Type.h"
14 #include "Linkage.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/CharUnits.h"
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/DeclBase.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/DependenceFlags.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/NestedNameSpecifier.h"
26 #include "clang/AST/NonTrivialTypeVisitor.h"
27 #include "clang/AST/PrettyPrinter.h"
28 #include "clang/AST/TemplateBase.h"
29 #include "clang/AST/TemplateName.h"
30 #include "clang/AST/TypeVisitor.h"
31 #include "clang/Basic/AddressSpaces.h"
32 #include "clang/Basic/ExceptionSpecificationType.h"
33 #include "clang/Basic/IdentifierTable.h"
34 #include "clang/Basic/LLVM.h"
35 #include "clang/Basic/LangOptions.h"
36 #include "clang/Basic/Linkage.h"
37 #include "clang/Basic/Specifiers.h"
38 #include "clang/Basic/TargetCXXABI.h"
39 #include "clang/Basic/TargetInfo.h"
40 #include "clang/Basic/Visibility.h"
41 #include "llvm/ADT/APInt.h"
42 #include "llvm/ADT/APSInt.h"
43 #include "llvm/ADT/ArrayRef.h"
44 #include "llvm/ADT/FoldingSet.h"
45 #include "llvm/ADT/None.h"
46 #include "llvm/ADT/SmallVector.h"
47 #include "llvm/Support/Casting.h"
48 #include "llvm/Support/ErrorHandling.h"
49 #include "llvm/Support/MathExtras.h"
50 #include <algorithm>
51 #include <cassert>
52 #include <cstdint>
53 #include <cstring>
54 #include <type_traits>
55
56 using namespace clang;
57
isStrictSupersetOf(Qualifiers Other) const58 bool Qualifiers::isStrictSupersetOf(Qualifiers Other) const {
59 return (*this != Other) &&
60 // CVR qualifiers superset
61 (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) &&
62 // ObjC GC qualifiers superset
63 ((getObjCGCAttr() == Other.getObjCGCAttr()) ||
64 (hasObjCGCAttr() && !Other.hasObjCGCAttr())) &&
65 // Address space superset.
66 ((getAddressSpace() == Other.getAddressSpace()) ||
67 (hasAddressSpace()&& !Other.hasAddressSpace())) &&
68 // Lifetime qualifier superset.
69 ((getObjCLifetime() == Other.getObjCLifetime()) ||
70 (hasObjCLifetime() && !Other.hasObjCLifetime()));
71 }
72
getBaseTypeIdentifier() const73 const IdentifierInfo* QualType::getBaseTypeIdentifier() const {
74 const Type* ty = getTypePtr();
75 NamedDecl *ND = nullptr;
76 if (ty->isPointerType() || ty->isReferenceType())
77 return ty->getPointeeType().getBaseTypeIdentifier();
78 else if (ty->isRecordType())
79 ND = ty->castAs<RecordType>()->getDecl();
80 else if (ty->isEnumeralType())
81 ND = ty->castAs<EnumType>()->getDecl();
82 else if (ty->getTypeClass() == Type::Typedef)
83 ND = ty->castAs<TypedefType>()->getDecl();
84 else if (ty->isArrayType())
85 return ty->castAsArrayTypeUnsafe()->
86 getElementType().getBaseTypeIdentifier();
87
88 if (ND)
89 return ND->getIdentifier();
90 return nullptr;
91 }
92
mayBeDynamicClass() const93 bool QualType::mayBeDynamicClass() const {
94 const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
95 return ClassDecl && ClassDecl->mayBeDynamicClass();
96 }
97
mayBeNotDynamicClass() const98 bool QualType::mayBeNotDynamicClass() const {
99 const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
100 return !ClassDecl || ClassDecl->mayBeNonDynamicClass();
101 }
102
isConstant(QualType T,const ASTContext & Ctx)103 bool QualType::isConstant(QualType T, const ASTContext &Ctx) {
104 if (T.isConstQualified())
105 return true;
106
107 if (const ArrayType *AT = Ctx.getAsArrayType(T))
108 return AT->getElementType().isConstant(Ctx);
109
110 return T.getAddressSpace() == LangAS::opencl_constant;
111 }
112
113 // C++ [temp.dep.type]p1:
114 // A type is dependent if it is...
115 // - an array type constructed from any dependent type or whose
116 // size is specified by a constant expression that is
117 // value-dependent,
ArrayType(TypeClass tc,QualType et,QualType can,ArraySizeModifier sm,unsigned tq,const Expr * sz)118 ArrayType::ArrayType(TypeClass tc, QualType et, QualType can,
119 ArraySizeModifier sm, unsigned tq, const Expr *sz)
120 // Note, we need to check for DependentSizedArrayType explicitly here
121 // because we use a DependentSizedArrayType with no size expression as the
122 // type of a dependent array of unknown bound with a dependent braced
123 // initializer:
124 //
125 // template<int ...N> int arr[] = {N...};
126 : Type(tc, can,
127 et->getDependence() |
128 (sz ? toTypeDependence(
129 turnValueToTypeDependence(sz->getDependence()))
130 : TypeDependence::None) |
131 (tc == VariableArray ? TypeDependence::VariablyModified
132 : TypeDependence::None) |
133 (tc == DependentSizedArray
134 ? TypeDependence::DependentInstantiation
135 : TypeDependence::None)),
136 ElementType(et) {
137 ArrayTypeBits.IndexTypeQuals = tq;
138 ArrayTypeBits.SizeModifier = sm;
139 }
140
getNumAddressingBits(const ASTContext & Context,QualType ElementType,const llvm::APInt & NumElements)141 unsigned ConstantArrayType::getNumAddressingBits(const ASTContext &Context,
142 QualType ElementType,
143 const llvm::APInt &NumElements) {
144 uint64_t ElementSize = Context.getTypeSizeInChars(ElementType).getQuantity();
145
146 // Fast path the common cases so we can avoid the conservative computation
147 // below, which in common cases allocates "large" APSInt values, which are
148 // slow.
149
150 // If the element size is a power of 2, we can directly compute the additional
151 // number of addressing bits beyond those required for the element count.
152 if (llvm::isPowerOf2_64(ElementSize)) {
153 return NumElements.getActiveBits() + llvm::Log2_64(ElementSize);
154 }
155
156 // If both the element count and element size fit in 32-bits, we can do the
157 // computation directly in 64-bits.
158 if ((ElementSize >> 32) == 0 && NumElements.getBitWidth() <= 64 &&
159 (NumElements.getZExtValue() >> 32) == 0) {
160 uint64_t TotalSize = NumElements.getZExtValue() * ElementSize;
161 return 64 - llvm::countLeadingZeros(TotalSize);
162 }
163
164 // Otherwise, use APSInt to handle arbitrary sized values.
165 llvm::APSInt SizeExtended(NumElements, true);
166 unsigned SizeTypeBits = Context.getTypeSize(Context.getSizeType());
167 SizeExtended = SizeExtended.extend(std::max(SizeTypeBits,
168 SizeExtended.getBitWidth()) * 2);
169
170 llvm::APSInt TotalSize(llvm::APInt(SizeExtended.getBitWidth(), ElementSize));
171 TotalSize *= SizeExtended;
172
173 return TotalSize.getActiveBits();
174 }
175
getMaxSizeBits(const ASTContext & Context)176 unsigned ConstantArrayType::getMaxSizeBits(const ASTContext &Context) {
177 unsigned Bits = Context.getTypeSize(Context.getSizeType());
178
179 // Limit the number of bits in size_t so that maximal bit size fits 64 bit
180 // integer (see PR8256). We can do this as currently there is no hardware
181 // that supports full 64-bit virtual space.
182 if (Bits > 61)
183 Bits = 61;
184
185 return Bits;
186 }
187
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,QualType ET,const llvm::APInt & ArraySize,const Expr * SizeExpr,ArraySizeModifier SizeMod,unsigned TypeQuals)188 void ConstantArrayType::Profile(llvm::FoldingSetNodeID &ID,
189 const ASTContext &Context, QualType ET,
190 const llvm::APInt &ArraySize,
191 const Expr *SizeExpr, ArraySizeModifier SizeMod,
192 unsigned TypeQuals) {
193 ID.AddPointer(ET.getAsOpaquePtr());
194 ID.AddInteger(ArraySize.getZExtValue());
195 ID.AddInteger(SizeMod);
196 ID.AddInteger(TypeQuals);
197 ID.AddBoolean(SizeExpr != 0);
198 if (SizeExpr)
199 SizeExpr->Profile(ID, Context, true);
200 }
201
DependentSizedArrayType(const ASTContext & Context,QualType et,QualType can,Expr * e,ArraySizeModifier sm,unsigned tq,SourceRange brackets)202 DependentSizedArrayType::DependentSizedArrayType(const ASTContext &Context,
203 QualType et, QualType can,
204 Expr *e, ArraySizeModifier sm,
205 unsigned tq,
206 SourceRange brackets)
207 : ArrayType(DependentSizedArray, et, can, sm, tq, e),
208 Context(Context), SizeExpr((Stmt*) e), Brackets(brackets) {}
209
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,QualType ET,ArraySizeModifier SizeMod,unsigned TypeQuals,Expr * E)210 void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID,
211 const ASTContext &Context,
212 QualType ET,
213 ArraySizeModifier SizeMod,
214 unsigned TypeQuals,
215 Expr *E) {
216 ID.AddPointer(ET.getAsOpaquePtr());
217 ID.AddInteger(SizeMod);
218 ID.AddInteger(TypeQuals);
219 E->Profile(ID, Context, true);
220 }
221
DependentVectorType(const ASTContext & Context,QualType ElementType,QualType CanonType,Expr * SizeExpr,SourceLocation Loc,VectorType::VectorKind VecKind)222 DependentVectorType::DependentVectorType(const ASTContext &Context,
223 QualType ElementType,
224 QualType CanonType, Expr *SizeExpr,
225 SourceLocation Loc,
226 VectorType::VectorKind VecKind)
227 : Type(DependentVector, CanonType,
228 TypeDependence::DependentInstantiation |
229 ElementType->getDependence() |
230 (SizeExpr ? toTypeDependence(SizeExpr->getDependence())
231 : TypeDependence::None)),
232 Context(Context), ElementType(ElementType), SizeExpr(SizeExpr), Loc(Loc) {
233 VectorTypeBits.VecKind = VecKind;
234 }
235
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,QualType ElementType,const Expr * SizeExpr,VectorType::VectorKind VecKind)236 void DependentVectorType::Profile(llvm::FoldingSetNodeID &ID,
237 const ASTContext &Context,
238 QualType ElementType, const Expr *SizeExpr,
239 VectorType::VectorKind VecKind) {
240 ID.AddPointer(ElementType.getAsOpaquePtr());
241 ID.AddInteger(VecKind);
242 SizeExpr->Profile(ID, Context, true);
243 }
244
DependentSizedExtVectorType(const ASTContext & Context,QualType ElementType,QualType can,Expr * SizeExpr,SourceLocation loc)245 DependentSizedExtVectorType::DependentSizedExtVectorType(
246 const ASTContext &Context, QualType ElementType, QualType can,
247 Expr *SizeExpr, SourceLocation loc)
248 : Type(DependentSizedExtVector, can,
249 TypeDependence::DependentInstantiation |
250 ElementType->getDependence() |
251 (SizeExpr ? toTypeDependence(SizeExpr->getDependence())
252 : TypeDependence::None)),
253 Context(Context), SizeExpr(SizeExpr), ElementType(ElementType), loc(loc) {
254 }
255
256 void
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,QualType ElementType,Expr * SizeExpr)257 DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID,
258 const ASTContext &Context,
259 QualType ElementType, Expr *SizeExpr) {
260 ID.AddPointer(ElementType.getAsOpaquePtr());
261 SizeExpr->Profile(ID, Context, true);
262 }
263
DependentAddressSpaceType(const ASTContext & Context,QualType PointeeType,QualType can,Expr * AddrSpaceExpr,SourceLocation loc)264 DependentAddressSpaceType::DependentAddressSpaceType(const ASTContext &Context,
265 QualType PointeeType,
266 QualType can,
267 Expr *AddrSpaceExpr,
268 SourceLocation loc)
269 : Type(DependentAddressSpace, can,
270 TypeDependence::DependentInstantiation |
271 PointeeType->getDependence() |
272 (AddrSpaceExpr ? toTypeDependence(AddrSpaceExpr->getDependence())
273 : TypeDependence::None)),
274 Context(Context), AddrSpaceExpr(AddrSpaceExpr), PointeeType(PointeeType),
275 loc(loc) {}
276
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,QualType PointeeType,Expr * AddrSpaceExpr)277 void DependentAddressSpaceType::Profile(llvm::FoldingSetNodeID &ID,
278 const ASTContext &Context,
279 QualType PointeeType,
280 Expr *AddrSpaceExpr) {
281 ID.AddPointer(PointeeType.getAsOpaquePtr());
282 AddrSpaceExpr->Profile(ID, Context, true);
283 }
284
MatrixType(TypeClass tc,QualType matrixType,QualType canonType,const Expr * RowExpr,const Expr * ColumnExpr)285 MatrixType::MatrixType(TypeClass tc, QualType matrixType, QualType canonType,
286 const Expr *RowExpr, const Expr *ColumnExpr)
287 : Type(tc, canonType,
288 (RowExpr ? (matrixType->getDependence() | TypeDependence::Dependent |
289 TypeDependence::Instantiation |
290 (matrixType->isVariablyModifiedType()
291 ? TypeDependence::VariablyModified
292 : TypeDependence::None) |
293 (matrixType->containsUnexpandedParameterPack() ||
294 (RowExpr &&
295 RowExpr->containsUnexpandedParameterPack()) ||
296 (ColumnExpr &&
297 ColumnExpr->containsUnexpandedParameterPack())
298 ? TypeDependence::UnexpandedPack
299 : TypeDependence::None))
300 : matrixType->getDependence())),
301 ElementType(matrixType) {}
302
ConstantMatrixType(QualType matrixType,unsigned nRows,unsigned nColumns,QualType canonType)303 ConstantMatrixType::ConstantMatrixType(QualType matrixType, unsigned nRows,
304 unsigned nColumns, QualType canonType)
305 : ConstantMatrixType(ConstantMatrix, matrixType, nRows, nColumns,
306 canonType) {}
307
ConstantMatrixType(TypeClass tc,QualType matrixType,unsigned nRows,unsigned nColumns,QualType canonType)308 ConstantMatrixType::ConstantMatrixType(TypeClass tc, QualType matrixType,
309 unsigned nRows, unsigned nColumns,
310 QualType canonType)
311 : MatrixType(tc, matrixType, canonType), NumRows(nRows),
312 NumColumns(nColumns) {}
313
DependentSizedMatrixType(const ASTContext & CTX,QualType ElementType,QualType CanonicalType,Expr * RowExpr,Expr * ColumnExpr,SourceLocation loc)314 DependentSizedMatrixType::DependentSizedMatrixType(
315 const ASTContext &CTX, QualType ElementType, QualType CanonicalType,
316 Expr *RowExpr, Expr *ColumnExpr, SourceLocation loc)
317 : MatrixType(DependentSizedMatrix, ElementType, CanonicalType, RowExpr,
318 ColumnExpr),
319 Context(CTX), RowExpr(RowExpr), ColumnExpr(ColumnExpr), loc(loc) {}
320
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & CTX,QualType ElementType,Expr * RowExpr,Expr * ColumnExpr)321 void DependentSizedMatrixType::Profile(llvm::FoldingSetNodeID &ID,
322 const ASTContext &CTX,
323 QualType ElementType, Expr *RowExpr,
324 Expr *ColumnExpr) {
325 ID.AddPointer(ElementType.getAsOpaquePtr());
326 RowExpr->Profile(ID, CTX, true);
327 ColumnExpr->Profile(ID, CTX, true);
328 }
329
VectorType(QualType vecType,unsigned nElements,QualType canonType,VectorKind vecKind)330 VectorType::VectorType(QualType vecType, unsigned nElements, QualType canonType,
331 VectorKind vecKind)
332 : VectorType(Vector, vecType, nElements, canonType, vecKind) {}
333
VectorType(TypeClass tc,QualType vecType,unsigned nElements,QualType canonType,VectorKind vecKind)334 VectorType::VectorType(TypeClass tc, QualType vecType, unsigned nElements,
335 QualType canonType, VectorKind vecKind)
336 : Type(tc, canonType, vecType->getDependence()), ElementType(vecType) {
337 VectorTypeBits.VecKind = vecKind;
338 VectorTypeBits.NumElements = nElements;
339 }
340
ExtIntType(bool IsUnsigned,unsigned NumBits)341 ExtIntType::ExtIntType(bool IsUnsigned, unsigned NumBits)
342 : Type(ExtInt, QualType{}, TypeDependence::None), IsUnsigned(IsUnsigned),
343 NumBits(NumBits) {}
344
DependentExtIntType(const ASTContext & Context,bool IsUnsigned,Expr * NumBitsExpr)345 DependentExtIntType::DependentExtIntType(const ASTContext &Context,
346 bool IsUnsigned, Expr *NumBitsExpr)
347 : Type(DependentExtInt, QualType{},
348 toTypeDependence(NumBitsExpr->getDependence())),
349 Context(Context), ExprAndUnsigned(NumBitsExpr, IsUnsigned) {}
350
isUnsigned() const351 bool DependentExtIntType::isUnsigned() const {
352 return ExprAndUnsigned.getInt();
353 }
354
getNumBitsExpr() const355 clang::Expr *DependentExtIntType::getNumBitsExpr() const {
356 return ExprAndUnsigned.getPointer();
357 }
358
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,bool IsUnsigned,Expr * NumBitsExpr)359 void DependentExtIntType::Profile(llvm::FoldingSetNodeID &ID,
360 const ASTContext &Context, bool IsUnsigned,
361 Expr *NumBitsExpr) {
362 ID.AddBoolean(IsUnsigned);
363 NumBitsExpr->Profile(ID, Context, true);
364 }
365
366 /// getArrayElementTypeNoTypeQual - If this is an array type, return the
367 /// element type of the array, potentially with type qualifiers missing.
368 /// This method should never be used when type qualifiers are meaningful.
getArrayElementTypeNoTypeQual() const369 const Type *Type::getArrayElementTypeNoTypeQual() const {
370 // If this is directly an array type, return it.
371 if (const auto *ATy = dyn_cast<ArrayType>(this))
372 return ATy->getElementType().getTypePtr();
373
374 // If the canonical form of this type isn't the right kind, reject it.
375 if (!isa<ArrayType>(CanonicalType))
376 return nullptr;
377
378 // If this is a typedef for an array type, strip the typedef off without
379 // losing all typedef information.
380 return cast<ArrayType>(getUnqualifiedDesugaredType())
381 ->getElementType().getTypePtr();
382 }
383
384 /// getDesugaredType - Return the specified type with any "sugar" removed from
385 /// the type. This takes off typedefs, typeof's etc. If the outer level of
386 /// the type is already concrete, it returns it unmodified. This is similar
387 /// to getting the canonical type, but it doesn't remove *all* typedefs. For
388 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
389 /// concrete.
getDesugaredType(QualType T,const ASTContext & Context)390 QualType QualType::getDesugaredType(QualType T, const ASTContext &Context) {
391 SplitQualType split = getSplitDesugaredType(T);
392 return Context.getQualifiedType(split.Ty, split.Quals);
393 }
394
getSingleStepDesugaredTypeImpl(QualType type,const ASTContext & Context)395 QualType QualType::getSingleStepDesugaredTypeImpl(QualType type,
396 const ASTContext &Context) {
397 SplitQualType split = type.split();
398 QualType desugar = split.Ty->getLocallyUnqualifiedSingleStepDesugaredType();
399 return Context.getQualifiedType(desugar, split.Quals);
400 }
401
402 // Check that no type class is polymorphic. LLVM style RTTI should be used
403 // instead. If absolutely needed an exception can still be added here by
404 // defining the appropriate macro (but please don't do this).
405 #define TYPE(CLASS, BASE) \
406 static_assert(!std::is_polymorphic<CLASS##Type>::value, \
407 #CLASS "Type should not be polymorphic!");
408 #include "clang/AST/TypeNodes.inc"
409
410 // Check that no type class has a non-trival destructor. Types are
411 // allocated with the BumpPtrAllocator from ASTContext and therefore
412 // their destructor is not executed.
413 //
414 // FIXME: ConstantArrayType is not trivially destructible because of its
415 // APInt member. It should be replaced in favor of ASTContext allocation.
416 #define TYPE(CLASS, BASE) \
417 static_assert(std::is_trivially_destructible<CLASS##Type>::value || \
418 std::is_same<CLASS##Type, ConstantArrayType>::value, \
419 #CLASS "Type should be trivially destructible!");
420 #include "clang/AST/TypeNodes.inc"
421
getLocallyUnqualifiedSingleStepDesugaredType() const422 QualType Type::getLocallyUnqualifiedSingleStepDesugaredType() const {
423 switch (getTypeClass()) {
424 #define ABSTRACT_TYPE(Class, Parent)
425 #define TYPE(Class, Parent) \
426 case Type::Class: { \
427 const auto *ty = cast<Class##Type>(this); \
428 if (!ty->isSugared()) return QualType(ty, 0); \
429 return ty->desugar(); \
430 }
431 #include "clang/AST/TypeNodes.inc"
432 }
433 llvm_unreachable("bad type kind!");
434 }
435
getSplitDesugaredType(QualType T)436 SplitQualType QualType::getSplitDesugaredType(QualType T) {
437 QualifierCollector Qs;
438
439 QualType Cur = T;
440 while (true) {
441 const Type *CurTy = Qs.strip(Cur);
442 switch (CurTy->getTypeClass()) {
443 #define ABSTRACT_TYPE(Class, Parent)
444 #define TYPE(Class, Parent) \
445 case Type::Class: { \
446 const auto *Ty = cast<Class##Type>(CurTy); \
447 if (!Ty->isSugared()) \
448 return SplitQualType(Ty, Qs); \
449 Cur = Ty->desugar(); \
450 break; \
451 }
452 #include "clang/AST/TypeNodes.inc"
453 }
454 }
455 }
456
getSplitUnqualifiedTypeImpl(QualType type)457 SplitQualType QualType::getSplitUnqualifiedTypeImpl(QualType type) {
458 SplitQualType split = type.split();
459
460 // All the qualifiers we've seen so far.
461 Qualifiers quals = split.Quals;
462
463 // The last type node we saw with any nodes inside it.
464 const Type *lastTypeWithQuals = split.Ty;
465
466 while (true) {
467 QualType next;
468
469 // Do a single-step desugar, aborting the loop if the type isn't
470 // sugared.
471 switch (split.Ty->getTypeClass()) {
472 #define ABSTRACT_TYPE(Class, Parent)
473 #define TYPE(Class, Parent) \
474 case Type::Class: { \
475 const auto *ty = cast<Class##Type>(split.Ty); \
476 if (!ty->isSugared()) goto done; \
477 next = ty->desugar(); \
478 break; \
479 }
480 #include "clang/AST/TypeNodes.inc"
481 }
482
483 // Otherwise, split the underlying type. If that yields qualifiers,
484 // update the information.
485 split = next.split();
486 if (!split.Quals.empty()) {
487 lastTypeWithQuals = split.Ty;
488 quals.addConsistentQualifiers(split.Quals);
489 }
490 }
491
492 done:
493 return SplitQualType(lastTypeWithQuals, quals);
494 }
495
IgnoreParens(QualType T)496 QualType QualType::IgnoreParens(QualType T) {
497 // FIXME: this seems inherently un-qualifiers-safe.
498 while (const auto *PT = T->getAs<ParenType>())
499 T = PT->getInnerType();
500 return T;
501 }
502
503 /// This will check for a T (which should be a Type which can act as
504 /// sugar, such as a TypedefType) by removing any existing sugar until it
505 /// reaches a T or a non-sugared type.
getAsSugar(const Type * Cur)506 template<typename T> static const T *getAsSugar(const Type *Cur) {
507 while (true) {
508 if (const auto *Sugar = dyn_cast<T>(Cur))
509 return Sugar;
510 switch (Cur->getTypeClass()) {
511 #define ABSTRACT_TYPE(Class, Parent)
512 #define TYPE(Class, Parent) \
513 case Type::Class: { \
514 const auto *Ty = cast<Class##Type>(Cur); \
515 if (!Ty->isSugared()) return 0; \
516 Cur = Ty->desugar().getTypePtr(); \
517 break; \
518 }
519 #include "clang/AST/TypeNodes.inc"
520 }
521 }
522 }
523
getAs() const524 template <> const TypedefType *Type::getAs() const {
525 return getAsSugar<TypedefType>(this);
526 }
527
getAs() const528 template <> const TemplateSpecializationType *Type::getAs() const {
529 return getAsSugar<TemplateSpecializationType>(this);
530 }
531
getAs() const532 template <> const AttributedType *Type::getAs() const {
533 return getAsSugar<AttributedType>(this);
534 }
535
536 /// getUnqualifiedDesugaredType - Pull any qualifiers and syntactic
537 /// sugar off the given type. This should produce an object of the
538 /// same dynamic type as the canonical type.
getUnqualifiedDesugaredType() const539 const Type *Type::getUnqualifiedDesugaredType() const {
540 const Type *Cur = this;
541
542 while (true) {
543 switch (Cur->getTypeClass()) {
544 #define ABSTRACT_TYPE(Class, Parent)
545 #define TYPE(Class, Parent) \
546 case Class: { \
547 const auto *Ty = cast<Class##Type>(Cur); \
548 if (!Ty->isSugared()) return Cur; \
549 Cur = Ty->desugar().getTypePtr(); \
550 break; \
551 }
552 #include "clang/AST/TypeNodes.inc"
553 }
554 }
555 }
556
isClassType() const557 bool Type::isClassType() const {
558 if (const auto *RT = getAs<RecordType>())
559 return RT->getDecl()->isClass();
560 return false;
561 }
562
isStructureType() const563 bool Type::isStructureType() const {
564 if (const auto *RT = getAs<RecordType>())
565 return RT->getDecl()->isStruct();
566 return false;
567 }
568
isObjCBoxableRecordType() const569 bool Type::isObjCBoxableRecordType() const {
570 if (const auto *RT = getAs<RecordType>())
571 return RT->getDecl()->hasAttr<ObjCBoxableAttr>();
572 return false;
573 }
574
isInterfaceType() const575 bool Type::isInterfaceType() const {
576 if (const auto *RT = getAs<RecordType>())
577 return RT->getDecl()->isInterface();
578 return false;
579 }
580
isStructureOrClassType() const581 bool Type::isStructureOrClassType() const {
582 if (const auto *RT = getAs<RecordType>()) {
583 RecordDecl *RD = RT->getDecl();
584 return RD->isStruct() || RD->isClass() || RD->isInterface();
585 }
586 return false;
587 }
588
isVoidPointerType() const589 bool Type::isVoidPointerType() const {
590 if (const auto *PT = getAs<PointerType>())
591 return PT->getPointeeType()->isVoidType();
592 return false;
593 }
594
isUnionType() const595 bool Type::isUnionType() const {
596 if (const auto *RT = getAs<RecordType>())
597 return RT->getDecl()->isUnion();
598 return false;
599 }
600
isComplexType() const601 bool Type::isComplexType() const {
602 if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
603 return CT->getElementType()->isFloatingType();
604 return false;
605 }
606
isComplexIntegerType() const607 bool Type::isComplexIntegerType() const {
608 // Check for GCC complex integer extension.
609 return getAsComplexIntegerType();
610 }
611
isScopedEnumeralType() const612 bool Type::isScopedEnumeralType() const {
613 if (const auto *ET = getAs<EnumType>())
614 return ET->getDecl()->isScoped();
615 return false;
616 }
617
getAsComplexIntegerType() const618 const ComplexType *Type::getAsComplexIntegerType() const {
619 if (const auto *Complex = getAs<ComplexType>())
620 if (Complex->getElementType()->isIntegerType())
621 return Complex;
622 return nullptr;
623 }
624
getPointeeType() const625 QualType Type::getPointeeType() const {
626 if (const auto *PT = getAs<PointerType>())
627 return PT->getPointeeType();
628 if (const auto *OPT = getAs<ObjCObjectPointerType>())
629 return OPT->getPointeeType();
630 if (const auto *BPT = getAs<BlockPointerType>())
631 return BPT->getPointeeType();
632 if (const auto *RT = getAs<ReferenceType>())
633 return RT->getPointeeType();
634 if (const auto *MPT = getAs<MemberPointerType>())
635 return MPT->getPointeeType();
636 if (const auto *DT = getAs<DecayedType>())
637 return DT->getPointeeType();
638 return {};
639 }
640
getAsStructureType() const641 const RecordType *Type::getAsStructureType() const {
642 // If this is directly a structure type, return it.
643 if (const auto *RT = dyn_cast<RecordType>(this)) {
644 if (RT->getDecl()->isStruct())
645 return RT;
646 }
647
648 // If the canonical form of this type isn't the right kind, reject it.
649 if (const auto *RT = dyn_cast<RecordType>(CanonicalType)) {
650 if (!RT->getDecl()->isStruct())
651 return nullptr;
652
653 // If this is a typedef for a structure type, strip the typedef off without
654 // losing all typedef information.
655 return cast<RecordType>(getUnqualifiedDesugaredType());
656 }
657 return nullptr;
658 }
659
getAsUnionType() const660 const RecordType *Type::getAsUnionType() const {
661 // If this is directly a union type, return it.
662 if (const auto *RT = dyn_cast<RecordType>(this)) {
663 if (RT->getDecl()->isUnion())
664 return RT;
665 }
666
667 // If the canonical form of this type isn't the right kind, reject it.
668 if (const auto *RT = dyn_cast<RecordType>(CanonicalType)) {
669 if (!RT->getDecl()->isUnion())
670 return nullptr;
671
672 // If this is a typedef for a union type, strip the typedef off without
673 // losing all typedef information.
674 return cast<RecordType>(getUnqualifiedDesugaredType());
675 }
676
677 return nullptr;
678 }
679
isObjCIdOrObjectKindOfType(const ASTContext & ctx,const ObjCObjectType * & bound) const680 bool Type::isObjCIdOrObjectKindOfType(const ASTContext &ctx,
681 const ObjCObjectType *&bound) const {
682 bound = nullptr;
683
684 const auto *OPT = getAs<ObjCObjectPointerType>();
685 if (!OPT)
686 return false;
687
688 // Easy case: id.
689 if (OPT->isObjCIdType())
690 return true;
691
692 // If it's not a __kindof type, reject it now.
693 if (!OPT->isKindOfType())
694 return false;
695
696 // If it's Class or qualified Class, it's not an object type.
697 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType())
698 return false;
699
700 // Figure out the type bound for the __kindof type.
701 bound = OPT->getObjectType()->stripObjCKindOfTypeAndQuals(ctx)
702 ->getAs<ObjCObjectType>();
703 return true;
704 }
705
isObjCClassOrClassKindOfType() const706 bool Type::isObjCClassOrClassKindOfType() const {
707 const auto *OPT = getAs<ObjCObjectPointerType>();
708 if (!OPT)
709 return false;
710
711 // Easy case: Class.
712 if (OPT->isObjCClassType())
713 return true;
714
715 // If it's not a __kindof type, reject it now.
716 if (!OPT->isKindOfType())
717 return false;
718
719 // If it's Class or qualified Class, it's a class __kindof type.
720 return OPT->isObjCClassType() || OPT->isObjCQualifiedClassType();
721 }
722
ObjCTypeParamType(const ObjCTypeParamDecl * D,QualType can,ArrayRef<ObjCProtocolDecl * > protocols)723 ObjCTypeParamType::ObjCTypeParamType(const ObjCTypeParamDecl *D, QualType can,
724 ArrayRef<ObjCProtocolDecl *> protocols)
725 : Type(ObjCTypeParam, can,
726 can->getDependence() & ~TypeDependence::UnexpandedPack),
727 OTPDecl(const_cast<ObjCTypeParamDecl *>(D)) {
728 initialize(protocols);
729 }
730
ObjCObjectType(QualType Canonical,QualType Base,ArrayRef<QualType> typeArgs,ArrayRef<ObjCProtocolDecl * > protocols,bool isKindOf)731 ObjCObjectType::ObjCObjectType(QualType Canonical, QualType Base,
732 ArrayRef<QualType> typeArgs,
733 ArrayRef<ObjCProtocolDecl *> protocols,
734 bool isKindOf)
735 : Type(ObjCObject, Canonical, Base->getDependence()), BaseType(Base) {
736 ObjCObjectTypeBits.IsKindOf = isKindOf;
737
738 ObjCObjectTypeBits.NumTypeArgs = typeArgs.size();
739 assert(getTypeArgsAsWritten().size() == typeArgs.size() &&
740 "bitfield overflow in type argument count");
741 if (!typeArgs.empty())
742 memcpy(getTypeArgStorage(), typeArgs.data(),
743 typeArgs.size() * sizeof(QualType));
744
745 for (auto typeArg : typeArgs) {
746 addDependence(typeArg->getDependence() & ~TypeDependence::VariablyModified);
747 }
748 // Initialize the protocol qualifiers. The protocol storage is known
749 // after we set number of type arguments.
750 initialize(protocols);
751 }
752
isSpecialized() const753 bool ObjCObjectType::isSpecialized() const {
754 // If we have type arguments written here, the type is specialized.
755 if (ObjCObjectTypeBits.NumTypeArgs > 0)
756 return true;
757
758 // Otherwise, check whether the base type is specialized.
759 if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
760 // Terminate when we reach an interface type.
761 if (isa<ObjCInterfaceType>(objcObject))
762 return false;
763
764 return objcObject->isSpecialized();
765 }
766
767 // Not specialized.
768 return false;
769 }
770
getTypeArgs() const771 ArrayRef<QualType> ObjCObjectType::getTypeArgs() const {
772 // We have type arguments written on this type.
773 if (isSpecializedAsWritten())
774 return getTypeArgsAsWritten();
775
776 // Look at the base type, which might have type arguments.
777 if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
778 // Terminate when we reach an interface type.
779 if (isa<ObjCInterfaceType>(objcObject))
780 return {};
781
782 return objcObject->getTypeArgs();
783 }
784
785 // No type arguments.
786 return {};
787 }
788
isKindOfType() const789 bool ObjCObjectType::isKindOfType() const {
790 if (isKindOfTypeAsWritten())
791 return true;
792
793 // Look at the base type, which might have type arguments.
794 if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
795 // Terminate when we reach an interface type.
796 if (isa<ObjCInterfaceType>(objcObject))
797 return false;
798
799 return objcObject->isKindOfType();
800 }
801
802 // Not a "__kindof" type.
803 return false;
804 }
805
stripObjCKindOfTypeAndQuals(const ASTContext & ctx) const806 QualType ObjCObjectType::stripObjCKindOfTypeAndQuals(
807 const ASTContext &ctx) const {
808 if (!isKindOfType() && qual_empty())
809 return QualType(this, 0);
810
811 // Recursively strip __kindof.
812 SplitQualType splitBaseType = getBaseType().split();
813 QualType baseType(splitBaseType.Ty, 0);
814 if (const auto *baseObj = splitBaseType.Ty->getAs<ObjCObjectType>())
815 baseType = baseObj->stripObjCKindOfTypeAndQuals(ctx);
816
817 return ctx.getObjCObjectType(ctx.getQualifiedType(baseType,
818 splitBaseType.Quals),
819 getTypeArgsAsWritten(),
820 /*protocols=*/{},
821 /*isKindOf=*/false);
822 }
823
stripObjCKindOfTypeAndQuals(const ASTContext & ctx) const824 const ObjCObjectPointerType *ObjCObjectPointerType::stripObjCKindOfTypeAndQuals(
825 const ASTContext &ctx) const {
826 if (!isKindOfType() && qual_empty())
827 return this;
828
829 QualType obj = getObjectType()->stripObjCKindOfTypeAndQuals(ctx);
830 return ctx.getObjCObjectPointerType(obj)->castAs<ObjCObjectPointerType>();
831 }
832
833 namespace {
834
835 /// Visitor used to perform a simple type transformation that does not change
836 /// the semantics of the type.
837 template <typename Derived>
838 struct SimpleTransformVisitor : public TypeVisitor<Derived, QualType> {
839 ASTContext &Ctx;
840
recurse__anon8e5681340111::SimpleTransformVisitor841 QualType recurse(QualType type) {
842 // Split out the qualifiers from the type.
843 SplitQualType splitType = type.split();
844
845 // Visit the type itself.
846 QualType result = static_cast<Derived *>(this)->Visit(splitType.Ty);
847 if (result.isNull())
848 return result;
849
850 // Reconstruct the transformed type by applying the local qualifiers
851 // from the split type.
852 return Ctx.getQualifiedType(result, splitType.Quals);
853 }
854
855 public:
SimpleTransformVisitor__anon8e5681340111::SimpleTransformVisitor856 explicit SimpleTransformVisitor(ASTContext &ctx) : Ctx(ctx) {}
857
858 // None of the clients of this transformation can occur where
859 // there are dependent types, so skip dependent types.
860 #define TYPE(Class, Base)
861 #define DEPENDENT_TYPE(Class, Base) \
862 QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
863 #include "clang/AST/TypeNodes.inc"
864
865 #define TRIVIAL_TYPE_CLASS(Class) \
866 QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
867 #define SUGARED_TYPE_CLASS(Class) \
868 QualType Visit##Class##Type(const Class##Type *T) { \
869 if (!T->isSugared()) \
870 return QualType(T, 0); \
871 QualType desugaredType = recurse(T->desugar()); \
872 if (desugaredType.isNull()) \
873 return {}; \
874 if (desugaredType.getAsOpaquePtr() == T->desugar().getAsOpaquePtr()) \
875 return QualType(T, 0); \
876 return desugaredType; \
877 }
878
TRIVIAL_TYPE_CLASS__anon8e5681340111::SimpleTransformVisitor879 TRIVIAL_TYPE_CLASS(Builtin)
880
881 QualType VisitComplexType(const ComplexType *T) {
882 QualType elementType = recurse(T->getElementType());
883 if (elementType.isNull())
884 return {};
885
886 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
887 return QualType(T, 0);
888
889 return Ctx.getComplexType(elementType);
890 }
891
VisitPointerType__anon8e5681340111::SimpleTransformVisitor892 QualType VisitPointerType(const PointerType *T) {
893 QualType pointeeType = recurse(T->getPointeeType());
894 if (pointeeType.isNull())
895 return {};
896
897 if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
898 return QualType(T, 0);
899
900 return Ctx.getPointerType(pointeeType);
901 }
902
VisitBlockPointerType__anon8e5681340111::SimpleTransformVisitor903 QualType VisitBlockPointerType(const BlockPointerType *T) {
904 QualType pointeeType = recurse(T->getPointeeType());
905 if (pointeeType.isNull())
906 return {};
907
908 if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
909 return QualType(T, 0);
910
911 return Ctx.getBlockPointerType(pointeeType);
912 }
913
VisitLValueReferenceType__anon8e5681340111::SimpleTransformVisitor914 QualType VisitLValueReferenceType(const LValueReferenceType *T) {
915 QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
916 if (pointeeType.isNull())
917 return {};
918
919 if (pointeeType.getAsOpaquePtr()
920 == T->getPointeeTypeAsWritten().getAsOpaquePtr())
921 return QualType(T, 0);
922
923 return Ctx.getLValueReferenceType(pointeeType, T->isSpelledAsLValue());
924 }
925
VisitRValueReferenceType__anon8e5681340111::SimpleTransformVisitor926 QualType VisitRValueReferenceType(const RValueReferenceType *T) {
927 QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
928 if (pointeeType.isNull())
929 return {};
930
931 if (pointeeType.getAsOpaquePtr()
932 == T->getPointeeTypeAsWritten().getAsOpaquePtr())
933 return QualType(T, 0);
934
935 return Ctx.getRValueReferenceType(pointeeType);
936 }
937
VisitMemberPointerType__anon8e5681340111::SimpleTransformVisitor938 QualType VisitMemberPointerType(const MemberPointerType *T) {
939 QualType pointeeType = recurse(T->getPointeeType());
940 if (pointeeType.isNull())
941 return {};
942
943 if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
944 return QualType(T, 0);
945
946 return Ctx.getMemberPointerType(pointeeType, T->getClass());
947 }
948
VisitConstantArrayType__anon8e5681340111::SimpleTransformVisitor949 QualType VisitConstantArrayType(const ConstantArrayType *T) {
950 QualType elementType = recurse(T->getElementType());
951 if (elementType.isNull())
952 return {};
953
954 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
955 return QualType(T, 0);
956
957 return Ctx.getConstantArrayType(elementType, T->getSize(), T->getSizeExpr(),
958 T->getSizeModifier(),
959 T->getIndexTypeCVRQualifiers());
960 }
961
VisitVariableArrayType__anon8e5681340111::SimpleTransformVisitor962 QualType VisitVariableArrayType(const VariableArrayType *T) {
963 QualType elementType = recurse(T->getElementType());
964 if (elementType.isNull())
965 return {};
966
967 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
968 return QualType(T, 0);
969
970 return Ctx.getVariableArrayType(elementType, T->getSizeExpr(),
971 T->getSizeModifier(),
972 T->getIndexTypeCVRQualifiers(),
973 T->getBracketsRange());
974 }
975
VisitIncompleteArrayType__anon8e5681340111::SimpleTransformVisitor976 QualType VisitIncompleteArrayType(const IncompleteArrayType *T) {
977 QualType elementType = recurse(T->getElementType());
978 if (elementType.isNull())
979 return {};
980
981 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
982 return QualType(T, 0);
983
984 return Ctx.getIncompleteArrayType(elementType, T->getSizeModifier(),
985 T->getIndexTypeCVRQualifiers());
986 }
987
VisitVectorType__anon8e5681340111::SimpleTransformVisitor988 QualType VisitVectorType(const VectorType *T) {
989 QualType elementType = recurse(T->getElementType());
990 if (elementType.isNull())
991 return {};
992
993 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
994 return QualType(T, 0);
995
996 return Ctx.getVectorType(elementType, T->getNumElements(),
997 T->getVectorKind());
998 }
999
VisitExtVectorType__anon8e5681340111::SimpleTransformVisitor1000 QualType VisitExtVectorType(const ExtVectorType *T) {
1001 QualType elementType = recurse(T->getElementType());
1002 if (elementType.isNull())
1003 return {};
1004
1005 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
1006 return QualType(T, 0);
1007
1008 return Ctx.getExtVectorType(elementType, T->getNumElements());
1009 }
1010
VisitConstantMatrixType__anon8e5681340111::SimpleTransformVisitor1011 QualType VisitConstantMatrixType(const ConstantMatrixType *T) {
1012 QualType elementType = recurse(T->getElementType());
1013 if (elementType.isNull())
1014 return {};
1015 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
1016 return QualType(T, 0);
1017
1018 return Ctx.getConstantMatrixType(elementType, T->getNumRows(),
1019 T->getNumColumns());
1020 }
1021
VisitFunctionNoProtoType__anon8e5681340111::SimpleTransformVisitor1022 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1023 QualType returnType = recurse(T->getReturnType());
1024 if (returnType.isNull())
1025 return {};
1026
1027 if (returnType.getAsOpaquePtr() == T->getReturnType().getAsOpaquePtr())
1028 return QualType(T, 0);
1029
1030 return Ctx.getFunctionNoProtoType(returnType, T->getExtInfo());
1031 }
1032
VisitFunctionProtoType__anon8e5681340111::SimpleTransformVisitor1033 QualType VisitFunctionProtoType(const FunctionProtoType *T) {
1034 QualType returnType = recurse(T->getReturnType());
1035 if (returnType.isNull())
1036 return {};
1037
1038 // Transform parameter types.
1039 SmallVector<QualType, 4> paramTypes;
1040 bool paramChanged = false;
1041 for (auto paramType : T->getParamTypes()) {
1042 QualType newParamType = recurse(paramType);
1043 if (newParamType.isNull())
1044 return {};
1045
1046 if (newParamType.getAsOpaquePtr() != paramType.getAsOpaquePtr())
1047 paramChanged = true;
1048
1049 paramTypes.push_back(newParamType);
1050 }
1051
1052 // Transform extended info.
1053 FunctionProtoType::ExtProtoInfo info = T->getExtProtoInfo();
1054 bool exceptionChanged = false;
1055 if (info.ExceptionSpec.Type == EST_Dynamic) {
1056 SmallVector<QualType, 4> exceptionTypes;
1057 for (auto exceptionType : info.ExceptionSpec.Exceptions) {
1058 QualType newExceptionType = recurse(exceptionType);
1059 if (newExceptionType.isNull())
1060 return {};
1061
1062 if (newExceptionType.getAsOpaquePtr() != exceptionType.getAsOpaquePtr())
1063 exceptionChanged = true;
1064
1065 exceptionTypes.push_back(newExceptionType);
1066 }
1067
1068 if (exceptionChanged) {
1069 info.ExceptionSpec.Exceptions =
1070 llvm::makeArrayRef(exceptionTypes).copy(Ctx);
1071 }
1072 }
1073
1074 if (returnType.getAsOpaquePtr() == T->getReturnType().getAsOpaquePtr() &&
1075 !paramChanged && !exceptionChanged)
1076 return QualType(T, 0);
1077
1078 return Ctx.getFunctionType(returnType, paramTypes, info);
1079 }
1080
VisitParenType__anon8e5681340111::SimpleTransformVisitor1081 QualType VisitParenType(const ParenType *T) {
1082 QualType innerType = recurse(T->getInnerType());
1083 if (innerType.isNull())
1084 return {};
1085
1086 if (innerType.getAsOpaquePtr() == T->getInnerType().getAsOpaquePtr())
1087 return QualType(T, 0);
1088
1089 return Ctx.getParenType(innerType);
1090 }
1091
1092 SUGARED_TYPE_CLASS(Typedef)
SUGARED_TYPE_CLASS__anon8e5681340111::SimpleTransformVisitor1093 SUGARED_TYPE_CLASS(ObjCTypeParam)
1094 SUGARED_TYPE_CLASS(MacroQualified)
1095
1096 QualType VisitAdjustedType(const AdjustedType *T) {
1097 QualType originalType = recurse(T->getOriginalType());
1098 if (originalType.isNull())
1099 return {};
1100
1101 QualType adjustedType = recurse(T->getAdjustedType());
1102 if (adjustedType.isNull())
1103 return {};
1104
1105 if (originalType.getAsOpaquePtr()
1106 == T->getOriginalType().getAsOpaquePtr() &&
1107 adjustedType.getAsOpaquePtr() == T->getAdjustedType().getAsOpaquePtr())
1108 return QualType(T, 0);
1109
1110 return Ctx.getAdjustedType(originalType, adjustedType);
1111 }
1112
VisitDecayedType__anon8e5681340111::SimpleTransformVisitor1113 QualType VisitDecayedType(const DecayedType *T) {
1114 QualType originalType = recurse(T->getOriginalType());
1115 if (originalType.isNull())
1116 return {};
1117
1118 if (originalType.getAsOpaquePtr()
1119 == T->getOriginalType().getAsOpaquePtr())
1120 return QualType(T, 0);
1121
1122 return Ctx.getDecayedType(originalType);
1123 }
1124
1125 SUGARED_TYPE_CLASS(TypeOfExpr)
SUGARED_TYPE_CLASS__anon8e5681340111::SimpleTransformVisitor1126 SUGARED_TYPE_CLASS(TypeOf)
1127 SUGARED_TYPE_CLASS(Decltype)
1128 SUGARED_TYPE_CLASS(UnaryTransform)
1129 TRIVIAL_TYPE_CLASS(Record)
1130 TRIVIAL_TYPE_CLASS(Enum)
1131
1132 // FIXME: Non-trivial to implement, but important for C++
1133 SUGARED_TYPE_CLASS(Elaborated)
1134
1135 QualType VisitAttributedType(const AttributedType *T) {
1136 QualType modifiedType = recurse(T->getModifiedType());
1137 if (modifiedType.isNull())
1138 return {};
1139
1140 QualType equivalentType = recurse(T->getEquivalentType());
1141 if (equivalentType.isNull())
1142 return {};
1143
1144 if (modifiedType.getAsOpaquePtr()
1145 == T->getModifiedType().getAsOpaquePtr() &&
1146 equivalentType.getAsOpaquePtr()
1147 == T->getEquivalentType().getAsOpaquePtr())
1148 return QualType(T, 0);
1149
1150 return Ctx.getAttributedType(T->getAttrKind(), modifiedType,
1151 equivalentType);
1152 }
1153
VisitSubstTemplateTypeParmType__anon8e5681340111::SimpleTransformVisitor1154 QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
1155 QualType replacementType = recurse(T->getReplacementType());
1156 if (replacementType.isNull())
1157 return {};
1158
1159 if (replacementType.getAsOpaquePtr()
1160 == T->getReplacementType().getAsOpaquePtr())
1161 return QualType(T, 0);
1162
1163 return Ctx.getSubstTemplateTypeParmType(T->getReplacedParameter(),
1164 replacementType);
1165 }
1166
1167 // FIXME: Non-trivial to implement, but important for C++
SUGARED_TYPE_CLASS__anon8e5681340111::SimpleTransformVisitor1168 SUGARED_TYPE_CLASS(TemplateSpecialization)
1169
1170 QualType VisitAutoType(const AutoType *T) {
1171 if (!T->isDeduced())
1172 return QualType(T, 0);
1173
1174 QualType deducedType = recurse(T->getDeducedType());
1175 if (deducedType.isNull())
1176 return {};
1177
1178 if (deducedType.getAsOpaquePtr()
1179 == T->getDeducedType().getAsOpaquePtr())
1180 return QualType(T, 0);
1181
1182 return Ctx.getAutoType(deducedType, T->getKeyword(),
1183 T->isDependentType(), /*IsPack=*/false,
1184 T->getTypeConstraintConcept(),
1185 T->getTypeConstraintArguments());
1186 }
1187
VisitObjCObjectType__anon8e5681340111::SimpleTransformVisitor1188 QualType VisitObjCObjectType(const ObjCObjectType *T) {
1189 QualType baseType = recurse(T->getBaseType());
1190 if (baseType.isNull())
1191 return {};
1192
1193 // Transform type arguments.
1194 bool typeArgChanged = false;
1195 SmallVector<QualType, 4> typeArgs;
1196 for (auto typeArg : T->getTypeArgsAsWritten()) {
1197 QualType newTypeArg = recurse(typeArg);
1198 if (newTypeArg.isNull())
1199 return {};
1200
1201 if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr())
1202 typeArgChanged = true;
1203
1204 typeArgs.push_back(newTypeArg);
1205 }
1206
1207 if (baseType.getAsOpaquePtr() == T->getBaseType().getAsOpaquePtr() &&
1208 !typeArgChanged)
1209 return QualType(T, 0);
1210
1211 return Ctx.getObjCObjectType(baseType, typeArgs,
1212 llvm::makeArrayRef(T->qual_begin(),
1213 T->getNumProtocols()),
1214 T->isKindOfTypeAsWritten());
1215 }
1216
TRIVIAL_TYPE_CLASS__anon8e5681340111::SimpleTransformVisitor1217 TRIVIAL_TYPE_CLASS(ObjCInterface)
1218
1219 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1220 QualType pointeeType = recurse(T->getPointeeType());
1221 if (pointeeType.isNull())
1222 return {};
1223
1224 if (pointeeType.getAsOpaquePtr()
1225 == T->getPointeeType().getAsOpaquePtr())
1226 return QualType(T, 0);
1227
1228 return Ctx.getObjCObjectPointerType(pointeeType);
1229 }
1230
VisitAtomicType__anon8e5681340111::SimpleTransformVisitor1231 QualType VisitAtomicType(const AtomicType *T) {
1232 QualType valueType = recurse(T->getValueType());
1233 if (valueType.isNull())
1234 return {};
1235
1236 if (valueType.getAsOpaquePtr()
1237 == T->getValueType().getAsOpaquePtr())
1238 return QualType(T, 0);
1239
1240 return Ctx.getAtomicType(valueType);
1241 }
1242
1243 #undef TRIVIAL_TYPE_CLASS
1244 #undef SUGARED_TYPE_CLASS
1245 };
1246
1247 struct SubstObjCTypeArgsVisitor
1248 : public SimpleTransformVisitor<SubstObjCTypeArgsVisitor> {
1249 using BaseType = SimpleTransformVisitor<SubstObjCTypeArgsVisitor>;
1250
1251 ArrayRef<QualType> TypeArgs;
1252 ObjCSubstitutionContext SubstContext;
1253
SubstObjCTypeArgsVisitor__anon8e5681340111::SubstObjCTypeArgsVisitor1254 SubstObjCTypeArgsVisitor(ASTContext &ctx, ArrayRef<QualType> typeArgs,
1255 ObjCSubstitutionContext context)
1256 : BaseType(ctx), TypeArgs(typeArgs), SubstContext(context) {}
1257
VisitObjCTypeParamType__anon8e5681340111::SubstObjCTypeArgsVisitor1258 QualType VisitObjCTypeParamType(const ObjCTypeParamType *OTPTy) {
1259 // Replace an Objective-C type parameter reference with the corresponding
1260 // type argument.
1261 ObjCTypeParamDecl *typeParam = OTPTy->getDecl();
1262 // If we have type arguments, use them.
1263 if (!TypeArgs.empty()) {
1264 QualType argType = TypeArgs[typeParam->getIndex()];
1265 if (OTPTy->qual_empty())
1266 return argType;
1267
1268 // Apply protocol lists if exists.
1269 bool hasError;
1270 SmallVector<ObjCProtocolDecl *, 8> protocolsVec;
1271 protocolsVec.append(OTPTy->qual_begin(), OTPTy->qual_end());
1272 ArrayRef<ObjCProtocolDecl *> protocolsToApply = protocolsVec;
1273 return Ctx.applyObjCProtocolQualifiers(
1274 argType, protocolsToApply, hasError, true/*allowOnPointerType*/);
1275 }
1276
1277 switch (SubstContext) {
1278 case ObjCSubstitutionContext::Ordinary:
1279 case ObjCSubstitutionContext::Parameter:
1280 case ObjCSubstitutionContext::Superclass:
1281 // Substitute the bound.
1282 return typeParam->getUnderlyingType();
1283
1284 case ObjCSubstitutionContext::Result:
1285 case ObjCSubstitutionContext::Property: {
1286 // Substitute the __kindof form of the underlying type.
1287 const auto *objPtr =
1288 typeParam->getUnderlyingType()->castAs<ObjCObjectPointerType>();
1289
1290 // __kindof types, id, and Class don't need an additional
1291 // __kindof.
1292 if (objPtr->isKindOfType() || objPtr->isObjCIdOrClassType())
1293 return typeParam->getUnderlyingType();
1294
1295 // Add __kindof.
1296 const auto *obj = objPtr->getObjectType();
1297 QualType resultTy = Ctx.getObjCObjectType(
1298 obj->getBaseType(), obj->getTypeArgsAsWritten(), obj->getProtocols(),
1299 /*isKindOf=*/true);
1300
1301 // Rebuild object pointer type.
1302 return Ctx.getObjCObjectPointerType(resultTy);
1303 }
1304 }
1305 llvm_unreachable("Unexpected ObjCSubstitutionContext!");
1306 }
1307
VisitFunctionType__anon8e5681340111::SubstObjCTypeArgsVisitor1308 QualType VisitFunctionType(const FunctionType *funcType) {
1309 // If we have a function type, update the substitution context
1310 // appropriately.
1311
1312 //Substitute result type.
1313 QualType returnType = funcType->getReturnType().substObjCTypeArgs(
1314 Ctx, TypeArgs, ObjCSubstitutionContext::Result);
1315 if (returnType.isNull())
1316 return {};
1317
1318 // Handle non-prototyped functions, which only substitute into the result
1319 // type.
1320 if (isa<FunctionNoProtoType>(funcType)) {
1321 // If the return type was unchanged, do nothing.
1322 if (returnType.getAsOpaquePtr() ==
1323 funcType->getReturnType().getAsOpaquePtr())
1324 return BaseType::VisitFunctionType(funcType);
1325
1326 // Otherwise, build a new type.
1327 return Ctx.getFunctionNoProtoType(returnType, funcType->getExtInfo());
1328 }
1329
1330 const auto *funcProtoType = cast<FunctionProtoType>(funcType);
1331
1332 // Transform parameter types.
1333 SmallVector<QualType, 4> paramTypes;
1334 bool paramChanged = false;
1335 for (auto paramType : funcProtoType->getParamTypes()) {
1336 QualType newParamType = paramType.substObjCTypeArgs(
1337 Ctx, TypeArgs, ObjCSubstitutionContext::Parameter);
1338 if (newParamType.isNull())
1339 return {};
1340
1341 if (newParamType.getAsOpaquePtr() != paramType.getAsOpaquePtr())
1342 paramChanged = true;
1343
1344 paramTypes.push_back(newParamType);
1345 }
1346
1347 // Transform extended info.
1348 FunctionProtoType::ExtProtoInfo info = funcProtoType->getExtProtoInfo();
1349 bool exceptionChanged = false;
1350 if (info.ExceptionSpec.Type == EST_Dynamic) {
1351 SmallVector<QualType, 4> exceptionTypes;
1352 for (auto exceptionType : info.ExceptionSpec.Exceptions) {
1353 QualType newExceptionType = exceptionType.substObjCTypeArgs(
1354 Ctx, TypeArgs, ObjCSubstitutionContext::Ordinary);
1355 if (newExceptionType.isNull())
1356 return {};
1357
1358 if (newExceptionType.getAsOpaquePtr() != exceptionType.getAsOpaquePtr())
1359 exceptionChanged = true;
1360
1361 exceptionTypes.push_back(newExceptionType);
1362 }
1363
1364 if (exceptionChanged) {
1365 info.ExceptionSpec.Exceptions =
1366 llvm::makeArrayRef(exceptionTypes).copy(Ctx);
1367 }
1368 }
1369
1370 if (returnType.getAsOpaquePtr() ==
1371 funcProtoType->getReturnType().getAsOpaquePtr() &&
1372 !paramChanged && !exceptionChanged)
1373 return BaseType::VisitFunctionType(funcType);
1374
1375 return Ctx.getFunctionType(returnType, paramTypes, info);
1376 }
1377
VisitObjCObjectType__anon8e5681340111::SubstObjCTypeArgsVisitor1378 QualType VisitObjCObjectType(const ObjCObjectType *objcObjectType) {
1379 // Substitute into the type arguments of a specialized Objective-C object
1380 // type.
1381 if (objcObjectType->isSpecializedAsWritten()) {
1382 SmallVector<QualType, 4> newTypeArgs;
1383 bool anyChanged = false;
1384 for (auto typeArg : objcObjectType->getTypeArgsAsWritten()) {
1385 QualType newTypeArg = typeArg.substObjCTypeArgs(
1386 Ctx, TypeArgs, ObjCSubstitutionContext::Ordinary);
1387 if (newTypeArg.isNull())
1388 return {};
1389
1390 if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr()) {
1391 // If we're substituting based on an unspecialized context type,
1392 // produce an unspecialized type.
1393 ArrayRef<ObjCProtocolDecl *> protocols(
1394 objcObjectType->qual_begin(), objcObjectType->getNumProtocols());
1395 if (TypeArgs.empty() &&
1396 SubstContext != ObjCSubstitutionContext::Superclass) {
1397 return Ctx.getObjCObjectType(
1398 objcObjectType->getBaseType(), {}, protocols,
1399 objcObjectType->isKindOfTypeAsWritten());
1400 }
1401
1402 anyChanged = true;
1403 }
1404
1405 newTypeArgs.push_back(newTypeArg);
1406 }
1407
1408 if (anyChanged) {
1409 ArrayRef<ObjCProtocolDecl *> protocols(
1410 objcObjectType->qual_begin(), objcObjectType->getNumProtocols());
1411 return Ctx.getObjCObjectType(objcObjectType->getBaseType(), newTypeArgs,
1412 protocols,
1413 objcObjectType->isKindOfTypeAsWritten());
1414 }
1415 }
1416
1417 return BaseType::VisitObjCObjectType(objcObjectType);
1418 }
1419
VisitAttributedType__anon8e5681340111::SubstObjCTypeArgsVisitor1420 QualType VisitAttributedType(const AttributedType *attrType) {
1421 QualType newType = BaseType::VisitAttributedType(attrType);
1422 if (newType.isNull())
1423 return {};
1424
1425 const auto *newAttrType = dyn_cast<AttributedType>(newType.getTypePtr());
1426 if (!newAttrType || newAttrType->getAttrKind() != attr::ObjCKindOf)
1427 return newType;
1428
1429 // Find out if it's an Objective-C object or object pointer type;
1430 QualType newEquivType = newAttrType->getEquivalentType();
1431 const ObjCObjectPointerType *ptrType =
1432 newEquivType->getAs<ObjCObjectPointerType>();
1433 const ObjCObjectType *objType = ptrType
1434 ? ptrType->getObjectType()
1435 : newEquivType->getAs<ObjCObjectType>();
1436 if (!objType)
1437 return newType;
1438
1439 // Rebuild the "equivalent" type, which pushes __kindof down into
1440 // the object type.
1441 newEquivType = Ctx.getObjCObjectType(
1442 objType->getBaseType(), objType->getTypeArgsAsWritten(),
1443 objType->getProtocols(),
1444 // There is no need to apply kindof on an unqualified id type.
1445 /*isKindOf=*/objType->isObjCUnqualifiedId() ? false : true);
1446
1447 // If we started with an object pointer type, rebuild it.
1448 if (ptrType)
1449 newEquivType = Ctx.getObjCObjectPointerType(newEquivType);
1450
1451 // Rebuild the attributed type.
1452 return Ctx.getAttributedType(newAttrType->getAttrKind(),
1453 newAttrType->getModifiedType(), newEquivType);
1454 }
1455 };
1456
1457 struct StripObjCKindOfTypeVisitor
1458 : public SimpleTransformVisitor<StripObjCKindOfTypeVisitor> {
1459 using BaseType = SimpleTransformVisitor<StripObjCKindOfTypeVisitor>;
1460
StripObjCKindOfTypeVisitor__anon8e5681340111::StripObjCKindOfTypeVisitor1461 explicit StripObjCKindOfTypeVisitor(ASTContext &ctx) : BaseType(ctx) {}
1462
VisitObjCObjectType__anon8e5681340111::StripObjCKindOfTypeVisitor1463 QualType VisitObjCObjectType(const ObjCObjectType *objType) {
1464 if (!objType->isKindOfType())
1465 return BaseType::VisitObjCObjectType(objType);
1466
1467 QualType baseType = objType->getBaseType().stripObjCKindOfType(Ctx);
1468 return Ctx.getObjCObjectType(baseType, objType->getTypeArgsAsWritten(),
1469 objType->getProtocols(),
1470 /*isKindOf=*/false);
1471 }
1472 };
1473
1474 } // namespace
1475
1476 /// Substitute the given type arguments for Objective-C type
1477 /// parameters within the given type, recursively.
substObjCTypeArgs(ASTContext & ctx,ArrayRef<QualType> typeArgs,ObjCSubstitutionContext context) const1478 QualType QualType::substObjCTypeArgs(ASTContext &ctx,
1479 ArrayRef<QualType> typeArgs,
1480 ObjCSubstitutionContext context) const {
1481 SubstObjCTypeArgsVisitor visitor(ctx, typeArgs, context);
1482 return visitor.recurse(*this);
1483 }
1484
substObjCMemberType(QualType objectType,const DeclContext * dc,ObjCSubstitutionContext context) const1485 QualType QualType::substObjCMemberType(QualType objectType,
1486 const DeclContext *dc,
1487 ObjCSubstitutionContext context) const {
1488 if (auto subs = objectType->getObjCSubstitutions(dc))
1489 return substObjCTypeArgs(dc->getParentASTContext(), *subs, context);
1490
1491 return *this;
1492 }
1493
stripObjCKindOfType(const ASTContext & constCtx) const1494 QualType QualType::stripObjCKindOfType(const ASTContext &constCtx) const {
1495 // FIXME: Because ASTContext::getAttributedType() is non-const.
1496 auto &ctx = const_cast<ASTContext &>(constCtx);
1497 StripObjCKindOfTypeVisitor visitor(ctx);
1498 return visitor.recurse(*this);
1499 }
1500
getAtomicUnqualifiedType() const1501 QualType QualType::getAtomicUnqualifiedType() const {
1502 if (const auto AT = getTypePtr()->getAs<AtomicType>())
1503 return AT->getValueType().getUnqualifiedType();
1504 return getUnqualifiedType();
1505 }
1506
getObjCSubstitutions(const DeclContext * dc) const1507 Optional<ArrayRef<QualType>> Type::getObjCSubstitutions(
1508 const DeclContext *dc) const {
1509 // Look through method scopes.
1510 if (const auto method = dyn_cast<ObjCMethodDecl>(dc))
1511 dc = method->getDeclContext();
1512
1513 // Find the class or category in which the type we're substituting
1514 // was declared.
1515 const auto *dcClassDecl = dyn_cast<ObjCInterfaceDecl>(dc);
1516 const ObjCCategoryDecl *dcCategoryDecl = nullptr;
1517 ObjCTypeParamList *dcTypeParams = nullptr;
1518 if (dcClassDecl) {
1519 // If the class does not have any type parameters, there's no
1520 // substitution to do.
1521 dcTypeParams = dcClassDecl->getTypeParamList();
1522 if (!dcTypeParams)
1523 return None;
1524 } else {
1525 // If we are in neither a class nor a category, there's no
1526 // substitution to perform.
1527 dcCategoryDecl = dyn_cast<ObjCCategoryDecl>(dc);
1528 if (!dcCategoryDecl)
1529 return None;
1530
1531 // If the category does not have any type parameters, there's no
1532 // substitution to do.
1533 dcTypeParams = dcCategoryDecl->getTypeParamList();
1534 if (!dcTypeParams)
1535 return None;
1536
1537 dcClassDecl = dcCategoryDecl->getClassInterface();
1538 if (!dcClassDecl)
1539 return None;
1540 }
1541 assert(dcTypeParams && "No substitutions to perform");
1542 assert(dcClassDecl && "No class context");
1543
1544 // Find the underlying object type.
1545 const ObjCObjectType *objectType;
1546 if (const auto *objectPointerType = getAs<ObjCObjectPointerType>()) {
1547 objectType = objectPointerType->getObjectType();
1548 } else if (getAs<BlockPointerType>()) {
1549 ASTContext &ctx = dc->getParentASTContext();
1550 objectType = ctx.getObjCObjectType(ctx.ObjCBuiltinIdTy, {}, {})
1551 ->castAs<ObjCObjectType>();
1552 } else {
1553 objectType = getAs<ObjCObjectType>();
1554 }
1555
1556 /// Extract the class from the receiver object type.
1557 ObjCInterfaceDecl *curClassDecl = objectType ? objectType->getInterface()
1558 : nullptr;
1559 if (!curClassDecl) {
1560 // If we don't have a context type (e.g., this is "id" or some
1561 // variant thereof), substitute the bounds.
1562 return llvm::ArrayRef<QualType>();
1563 }
1564
1565 // Follow the superclass chain until we've mapped the receiver type
1566 // to the same class as the context.
1567 while (curClassDecl != dcClassDecl) {
1568 // Map to the superclass type.
1569 QualType superType = objectType->getSuperClassType();
1570 if (superType.isNull()) {
1571 objectType = nullptr;
1572 break;
1573 }
1574
1575 objectType = superType->castAs<ObjCObjectType>();
1576 curClassDecl = objectType->getInterface();
1577 }
1578
1579 // If we don't have a receiver type, or the receiver type does not
1580 // have type arguments, substitute in the defaults.
1581 if (!objectType || objectType->isUnspecialized()) {
1582 return llvm::ArrayRef<QualType>();
1583 }
1584
1585 // The receiver type has the type arguments we want.
1586 return objectType->getTypeArgs();
1587 }
1588
acceptsObjCTypeParams() const1589 bool Type::acceptsObjCTypeParams() const {
1590 if (auto *IfaceT = getAsObjCInterfaceType()) {
1591 if (auto *ID = IfaceT->getInterface()) {
1592 if (ID->getTypeParamList())
1593 return true;
1594 }
1595 }
1596
1597 return false;
1598 }
1599
computeSuperClassTypeSlow() const1600 void ObjCObjectType::computeSuperClassTypeSlow() const {
1601 // Retrieve the class declaration for this type. If there isn't one
1602 // (e.g., this is some variant of "id" or "Class"), then there is no
1603 // superclass type.
1604 ObjCInterfaceDecl *classDecl = getInterface();
1605 if (!classDecl) {
1606 CachedSuperClassType.setInt(true);
1607 return;
1608 }
1609
1610 // Extract the superclass type.
1611 const ObjCObjectType *superClassObjTy = classDecl->getSuperClassType();
1612 if (!superClassObjTy) {
1613 CachedSuperClassType.setInt(true);
1614 return;
1615 }
1616
1617 ObjCInterfaceDecl *superClassDecl = superClassObjTy->getInterface();
1618 if (!superClassDecl) {
1619 CachedSuperClassType.setInt(true);
1620 return;
1621 }
1622
1623 // If the superclass doesn't have type parameters, then there is no
1624 // substitution to perform.
1625 QualType superClassType(superClassObjTy, 0);
1626 ObjCTypeParamList *superClassTypeParams = superClassDecl->getTypeParamList();
1627 if (!superClassTypeParams) {
1628 CachedSuperClassType.setPointerAndInt(
1629 superClassType->castAs<ObjCObjectType>(), true);
1630 return;
1631 }
1632
1633 // If the superclass reference is unspecialized, return it.
1634 if (superClassObjTy->isUnspecialized()) {
1635 CachedSuperClassType.setPointerAndInt(superClassObjTy, true);
1636 return;
1637 }
1638
1639 // If the subclass is not parameterized, there aren't any type
1640 // parameters in the superclass reference to substitute.
1641 ObjCTypeParamList *typeParams = classDecl->getTypeParamList();
1642 if (!typeParams) {
1643 CachedSuperClassType.setPointerAndInt(
1644 superClassType->castAs<ObjCObjectType>(), true);
1645 return;
1646 }
1647
1648 // If the subclass type isn't specialized, return the unspecialized
1649 // superclass.
1650 if (isUnspecialized()) {
1651 QualType unspecializedSuper
1652 = classDecl->getASTContext().getObjCInterfaceType(
1653 superClassObjTy->getInterface());
1654 CachedSuperClassType.setPointerAndInt(
1655 unspecializedSuper->castAs<ObjCObjectType>(),
1656 true);
1657 return;
1658 }
1659
1660 // Substitute the provided type arguments into the superclass type.
1661 ArrayRef<QualType> typeArgs = getTypeArgs();
1662 assert(typeArgs.size() == typeParams->size());
1663 CachedSuperClassType.setPointerAndInt(
1664 superClassType.substObjCTypeArgs(classDecl->getASTContext(), typeArgs,
1665 ObjCSubstitutionContext::Superclass)
1666 ->castAs<ObjCObjectType>(),
1667 true);
1668 }
1669
getInterfaceType() const1670 const ObjCInterfaceType *ObjCObjectPointerType::getInterfaceType() const {
1671 if (auto interfaceDecl = getObjectType()->getInterface()) {
1672 return interfaceDecl->getASTContext().getObjCInterfaceType(interfaceDecl)
1673 ->castAs<ObjCInterfaceType>();
1674 }
1675
1676 return nullptr;
1677 }
1678
getSuperClassType() const1679 QualType ObjCObjectPointerType::getSuperClassType() const {
1680 QualType superObjectType = getObjectType()->getSuperClassType();
1681 if (superObjectType.isNull())
1682 return superObjectType;
1683
1684 ASTContext &ctx = getInterfaceDecl()->getASTContext();
1685 return ctx.getObjCObjectPointerType(superObjectType);
1686 }
1687
getAsObjCQualifiedInterfaceType() const1688 const ObjCObjectType *Type::getAsObjCQualifiedInterfaceType() const {
1689 // There is no sugar for ObjCObjectType's, just return the canonical
1690 // type pointer if it is the right class. There is no typedef information to
1691 // return and these cannot be Address-space qualified.
1692 if (const auto *T = getAs<ObjCObjectType>())
1693 if (T->getNumProtocols() && T->getInterface())
1694 return T;
1695 return nullptr;
1696 }
1697
isObjCQualifiedInterfaceType() const1698 bool Type::isObjCQualifiedInterfaceType() const {
1699 return getAsObjCQualifiedInterfaceType() != nullptr;
1700 }
1701
getAsObjCQualifiedIdType() const1702 const ObjCObjectPointerType *Type::getAsObjCQualifiedIdType() const {
1703 // There is no sugar for ObjCQualifiedIdType's, just return the canonical
1704 // type pointer if it is the right class.
1705 if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
1706 if (OPT->isObjCQualifiedIdType())
1707 return OPT;
1708 }
1709 return nullptr;
1710 }
1711
getAsObjCQualifiedClassType() const1712 const ObjCObjectPointerType *Type::getAsObjCQualifiedClassType() const {
1713 // There is no sugar for ObjCQualifiedClassType's, just return the canonical
1714 // type pointer if it is the right class.
1715 if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
1716 if (OPT->isObjCQualifiedClassType())
1717 return OPT;
1718 }
1719 return nullptr;
1720 }
1721
getAsObjCInterfaceType() const1722 const ObjCObjectType *Type::getAsObjCInterfaceType() const {
1723 if (const auto *OT = getAs<ObjCObjectType>()) {
1724 if (OT->getInterface())
1725 return OT;
1726 }
1727 return nullptr;
1728 }
1729
getAsObjCInterfacePointerType() const1730 const ObjCObjectPointerType *Type::getAsObjCInterfacePointerType() const {
1731 if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
1732 if (OPT->getInterfaceType())
1733 return OPT;
1734 }
1735 return nullptr;
1736 }
1737
getPointeeCXXRecordDecl() const1738 const CXXRecordDecl *Type::getPointeeCXXRecordDecl() const {
1739 QualType PointeeType;
1740 if (const auto *PT = getAs<PointerType>())
1741 PointeeType = PT->getPointeeType();
1742 else if (const auto *RT = getAs<ReferenceType>())
1743 PointeeType = RT->getPointeeType();
1744 else
1745 return nullptr;
1746
1747 if (const auto *RT = PointeeType->getAs<RecordType>())
1748 return dyn_cast<CXXRecordDecl>(RT->getDecl());
1749
1750 return nullptr;
1751 }
1752
getAsCXXRecordDecl() const1753 CXXRecordDecl *Type::getAsCXXRecordDecl() const {
1754 return dyn_cast_or_null<CXXRecordDecl>(getAsTagDecl());
1755 }
1756
getAsRecordDecl() const1757 RecordDecl *Type::getAsRecordDecl() const {
1758 return dyn_cast_or_null<RecordDecl>(getAsTagDecl());
1759 }
1760
getAsTagDecl() const1761 TagDecl *Type::getAsTagDecl() const {
1762 if (const auto *TT = getAs<TagType>())
1763 return TT->getDecl();
1764 if (const auto *Injected = getAs<InjectedClassNameType>())
1765 return Injected->getDecl();
1766
1767 return nullptr;
1768 }
1769
hasAttr(attr::Kind AK) const1770 bool Type::hasAttr(attr::Kind AK) const {
1771 const Type *Cur = this;
1772 while (const auto *AT = Cur->getAs<AttributedType>()) {
1773 if (AT->getAttrKind() == AK)
1774 return true;
1775 Cur = AT->getEquivalentType().getTypePtr();
1776 }
1777 return false;
1778 }
1779
1780 namespace {
1781
1782 class GetContainedDeducedTypeVisitor :
1783 public TypeVisitor<GetContainedDeducedTypeVisitor, Type*> {
1784 bool Syntactic;
1785
1786 public:
GetContainedDeducedTypeVisitor(bool Syntactic=false)1787 GetContainedDeducedTypeVisitor(bool Syntactic = false)
1788 : Syntactic(Syntactic) {}
1789
1790 using TypeVisitor<GetContainedDeducedTypeVisitor, Type*>::Visit;
1791
Visit(QualType T)1792 Type *Visit(QualType T) {
1793 if (T.isNull())
1794 return nullptr;
1795 return Visit(T.getTypePtr());
1796 }
1797
1798 // The deduced type itself.
VisitDeducedType(const DeducedType * AT)1799 Type *VisitDeducedType(const DeducedType *AT) {
1800 return const_cast<DeducedType*>(AT);
1801 }
1802
1803 // Only these types can contain the desired 'auto' type.
1804
VisitElaboratedType(const ElaboratedType * T)1805 Type *VisitElaboratedType(const ElaboratedType *T) {
1806 return Visit(T->getNamedType());
1807 }
1808
VisitPointerType(const PointerType * T)1809 Type *VisitPointerType(const PointerType *T) {
1810 return Visit(T->getPointeeType());
1811 }
1812
VisitBlockPointerType(const BlockPointerType * T)1813 Type *VisitBlockPointerType(const BlockPointerType *T) {
1814 return Visit(T->getPointeeType());
1815 }
1816
VisitReferenceType(const ReferenceType * T)1817 Type *VisitReferenceType(const ReferenceType *T) {
1818 return Visit(T->getPointeeTypeAsWritten());
1819 }
1820
VisitMemberPointerType(const MemberPointerType * T)1821 Type *VisitMemberPointerType(const MemberPointerType *T) {
1822 return Visit(T->getPointeeType());
1823 }
1824
VisitArrayType(const ArrayType * T)1825 Type *VisitArrayType(const ArrayType *T) {
1826 return Visit(T->getElementType());
1827 }
1828
VisitDependentSizedExtVectorType(const DependentSizedExtVectorType * T)1829 Type *VisitDependentSizedExtVectorType(
1830 const DependentSizedExtVectorType *T) {
1831 return Visit(T->getElementType());
1832 }
1833
VisitVectorType(const VectorType * T)1834 Type *VisitVectorType(const VectorType *T) {
1835 return Visit(T->getElementType());
1836 }
1837
VisitDependentSizedMatrixType(const DependentSizedMatrixType * T)1838 Type *VisitDependentSizedMatrixType(const DependentSizedMatrixType *T) {
1839 return Visit(T->getElementType());
1840 }
1841
VisitConstantMatrixType(const ConstantMatrixType * T)1842 Type *VisitConstantMatrixType(const ConstantMatrixType *T) {
1843 return Visit(T->getElementType());
1844 }
1845
VisitFunctionProtoType(const FunctionProtoType * T)1846 Type *VisitFunctionProtoType(const FunctionProtoType *T) {
1847 if (Syntactic && T->hasTrailingReturn())
1848 return const_cast<FunctionProtoType*>(T);
1849 return VisitFunctionType(T);
1850 }
1851
VisitFunctionType(const FunctionType * T)1852 Type *VisitFunctionType(const FunctionType *T) {
1853 return Visit(T->getReturnType());
1854 }
1855
VisitParenType(const ParenType * T)1856 Type *VisitParenType(const ParenType *T) {
1857 return Visit(T->getInnerType());
1858 }
1859
VisitAttributedType(const AttributedType * T)1860 Type *VisitAttributedType(const AttributedType *T) {
1861 return Visit(T->getModifiedType());
1862 }
1863
VisitMacroQualifiedType(const MacroQualifiedType * T)1864 Type *VisitMacroQualifiedType(const MacroQualifiedType *T) {
1865 return Visit(T->getUnderlyingType());
1866 }
1867
VisitAdjustedType(const AdjustedType * T)1868 Type *VisitAdjustedType(const AdjustedType *T) {
1869 return Visit(T->getOriginalType());
1870 }
1871
VisitPackExpansionType(const PackExpansionType * T)1872 Type *VisitPackExpansionType(const PackExpansionType *T) {
1873 return Visit(T->getPattern());
1874 }
1875 };
1876
1877 } // namespace
1878
getContainedDeducedType() const1879 DeducedType *Type::getContainedDeducedType() const {
1880 return cast_or_null<DeducedType>(
1881 GetContainedDeducedTypeVisitor().Visit(this));
1882 }
1883
hasAutoForTrailingReturnType() const1884 bool Type::hasAutoForTrailingReturnType() const {
1885 return dyn_cast_or_null<FunctionType>(
1886 GetContainedDeducedTypeVisitor(true).Visit(this));
1887 }
1888
hasIntegerRepresentation() const1889 bool Type::hasIntegerRepresentation() const {
1890 if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
1891 return VT->getElementType()->isIntegerType();
1892 else
1893 return isIntegerType();
1894 }
1895
1896 /// Determine whether this type is an integral type.
1897 ///
1898 /// This routine determines whether the given type is an integral type per
1899 /// C++ [basic.fundamental]p7. Although the C standard does not define the
1900 /// term "integral type", it has a similar term "integer type", and in C++
1901 /// the two terms are equivalent. However, C's "integer type" includes
1902 /// enumeration types, while C++'s "integer type" does not. The \c ASTContext
1903 /// parameter is used to determine whether we should be following the C or
1904 /// C++ rules when determining whether this type is an integral/integer type.
1905 ///
1906 /// For cases where C permits "an integer type" and C++ permits "an integral
1907 /// type", use this routine.
1908 ///
1909 /// For cases where C permits "an integer type" and C++ permits "an integral
1910 /// or enumeration type", use \c isIntegralOrEnumerationType() instead.
1911 ///
1912 /// \param Ctx The context in which this type occurs.
1913 ///
1914 /// \returns true if the type is considered an integral type, false otherwise.
isIntegralType(const ASTContext & Ctx) const1915 bool Type::isIntegralType(const ASTContext &Ctx) const {
1916 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1917 return BT->getKind() >= BuiltinType::Bool &&
1918 BT->getKind() <= BuiltinType::Int128;
1919
1920 // Complete enum types are integral in C.
1921 if (!Ctx.getLangOpts().CPlusPlus)
1922 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
1923 return ET->getDecl()->isComplete();
1924
1925 return isExtIntType();
1926 }
1927
isIntegralOrUnscopedEnumerationType() const1928 bool Type::isIntegralOrUnscopedEnumerationType() const {
1929 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1930 return BT->getKind() >= BuiltinType::Bool &&
1931 BT->getKind() <= BuiltinType::Int128;
1932
1933 if (isExtIntType())
1934 return true;
1935
1936 return isUnscopedEnumerationType();
1937 }
1938
isUnscopedEnumerationType() const1939 bool Type::isUnscopedEnumerationType() const {
1940 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
1941 return !ET->getDecl()->isScoped();
1942
1943 return false;
1944 }
1945
isCharType() const1946 bool Type::isCharType() const {
1947 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1948 return BT->getKind() == BuiltinType::Char_U ||
1949 BT->getKind() == BuiltinType::UChar ||
1950 BT->getKind() == BuiltinType::Char_S ||
1951 BT->getKind() == BuiltinType::SChar;
1952 return false;
1953 }
1954
isWideCharType() const1955 bool Type::isWideCharType() const {
1956 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1957 return BT->getKind() == BuiltinType::WChar_S ||
1958 BT->getKind() == BuiltinType::WChar_U;
1959 return false;
1960 }
1961
isChar8Type() const1962 bool Type::isChar8Type() const {
1963 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1964 return BT->getKind() == BuiltinType::Char8;
1965 return false;
1966 }
1967
isChar16Type() const1968 bool Type::isChar16Type() const {
1969 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1970 return BT->getKind() == BuiltinType::Char16;
1971 return false;
1972 }
1973
isChar32Type() const1974 bool Type::isChar32Type() const {
1975 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1976 return BT->getKind() == BuiltinType::Char32;
1977 return false;
1978 }
1979
1980 /// Determine whether this type is any of the built-in character
1981 /// types.
isAnyCharacterType() const1982 bool Type::isAnyCharacterType() const {
1983 const auto *BT = dyn_cast<BuiltinType>(CanonicalType);
1984 if (!BT) return false;
1985 switch (BT->getKind()) {
1986 default: return false;
1987 case BuiltinType::Char_U:
1988 case BuiltinType::UChar:
1989 case BuiltinType::WChar_U:
1990 case BuiltinType::Char8:
1991 case BuiltinType::Char16:
1992 case BuiltinType::Char32:
1993 case BuiltinType::Char_S:
1994 case BuiltinType::SChar:
1995 case BuiltinType::WChar_S:
1996 return true;
1997 }
1998 }
1999
2000 /// isSignedIntegerType - Return true if this is an integer type that is
2001 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
2002 /// an enum decl which has a signed representation
isSignedIntegerType() const2003 bool Type::isSignedIntegerType() const {
2004 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
2005 return BT->getKind() >= BuiltinType::Char_S &&
2006 BT->getKind() <= BuiltinType::Int128;
2007 }
2008
2009 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
2010 // Incomplete enum types are not treated as integer types.
2011 // FIXME: In C++, enum types are never integer types.
2012 if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
2013 return ET->getDecl()->getIntegerType()->isSignedIntegerType();
2014 }
2015
2016 if (const ExtIntType *IT = dyn_cast<ExtIntType>(CanonicalType))
2017 return IT->isSigned();
2018
2019 return false;
2020 }
2021
isSignedIntegerOrEnumerationType() const2022 bool Type::isSignedIntegerOrEnumerationType() const {
2023 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
2024 return BT->getKind() >= BuiltinType::Char_S &&
2025 BT->getKind() <= BuiltinType::Int128;
2026 }
2027
2028 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
2029 if (ET->getDecl()->isComplete())
2030 return ET->getDecl()->getIntegerType()->isSignedIntegerType();
2031 }
2032
2033 if (const ExtIntType *IT = dyn_cast<ExtIntType>(CanonicalType))
2034 return IT->isSigned();
2035
2036
2037 return false;
2038 }
2039
hasSignedIntegerRepresentation() const2040 bool Type::hasSignedIntegerRepresentation() const {
2041 if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
2042 return VT->getElementType()->isSignedIntegerOrEnumerationType();
2043 else
2044 return isSignedIntegerOrEnumerationType();
2045 }
2046
2047 /// isUnsignedIntegerType - Return true if this is an integer type that is
2048 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum
2049 /// decl which has an unsigned representation
isUnsignedIntegerType() const2050 bool Type::isUnsignedIntegerType() const {
2051 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
2052 return BT->getKind() >= BuiltinType::Bool &&
2053 BT->getKind() <= BuiltinType::UInt128;
2054 }
2055
2056 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
2057 // Incomplete enum types are not treated as integer types.
2058 // FIXME: In C++, enum types are never integer types.
2059 if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
2060 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
2061 }
2062
2063 if (const ExtIntType *IT = dyn_cast<ExtIntType>(CanonicalType))
2064 return IT->isUnsigned();
2065
2066 return false;
2067 }
2068
isUnsignedIntegerOrEnumerationType() const2069 bool Type::isUnsignedIntegerOrEnumerationType() const {
2070 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
2071 return BT->getKind() >= BuiltinType::Bool &&
2072 BT->getKind() <= BuiltinType::UInt128;
2073 }
2074
2075 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
2076 if (ET->getDecl()->isComplete())
2077 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
2078 }
2079
2080 if (const ExtIntType *IT = dyn_cast<ExtIntType>(CanonicalType))
2081 return IT->isUnsigned();
2082
2083 return false;
2084 }
2085
hasUnsignedIntegerRepresentation() const2086 bool Type::hasUnsignedIntegerRepresentation() const {
2087 if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
2088 return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
2089 if (const auto *VT = dyn_cast<MatrixType>(CanonicalType))
2090 return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
2091 return isUnsignedIntegerOrEnumerationType();
2092 }
2093
isFloatingType() const2094 bool Type::isFloatingType() const {
2095 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2096 return BT->getKind() >= BuiltinType::Half &&
2097 BT->getKind() <= BuiltinType::Float128;
2098 if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
2099 return CT->getElementType()->isFloatingType();
2100 return false;
2101 }
2102
hasFloatingRepresentation() const2103 bool Type::hasFloatingRepresentation() const {
2104 if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
2105 return VT->getElementType()->isFloatingType();
2106 else
2107 return isFloatingType();
2108 }
2109
isRealFloatingType() const2110 bool Type::isRealFloatingType() const {
2111 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2112 return BT->isFloatingPoint();
2113 return false;
2114 }
2115
isRealType() const2116 bool Type::isRealType() const {
2117 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2118 return BT->getKind() >= BuiltinType::Bool &&
2119 BT->getKind() <= BuiltinType::Float128;
2120 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
2121 return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
2122 return isExtIntType();
2123 }
2124
isArithmeticType() const2125 bool Type::isArithmeticType() const {
2126 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2127 return BT->getKind() >= BuiltinType::Bool &&
2128 BT->getKind() <= BuiltinType::Float128 &&
2129 BT->getKind() != BuiltinType::BFloat16;
2130 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
2131 // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
2132 // If a body isn't seen by the time we get here, return false.
2133 //
2134 // C++0x: Enumerations are not arithmetic types. For now, just return
2135 // false for scoped enumerations since that will disable any
2136 // unwanted implicit conversions.
2137 return !ET->getDecl()->isScoped() && ET->getDecl()->isComplete();
2138 return isa<ComplexType>(CanonicalType) || isExtIntType();
2139 }
2140
getScalarTypeKind() const2141 Type::ScalarTypeKind Type::getScalarTypeKind() const {
2142 assert(isScalarType());
2143
2144 const Type *T = CanonicalType.getTypePtr();
2145 if (const auto *BT = dyn_cast<BuiltinType>(T)) {
2146 if (BT->getKind() == BuiltinType::Bool) return STK_Bool;
2147 if (BT->getKind() == BuiltinType::NullPtr) return STK_CPointer;
2148 if (BT->isInteger()) return STK_Integral;
2149 if (BT->isFloatingPoint()) return STK_Floating;
2150 if (BT->isFixedPointType()) return STK_FixedPoint;
2151 llvm_unreachable("unknown scalar builtin type");
2152 } else if (isa<PointerType>(T)) {
2153 return STK_CPointer;
2154 } else if (isa<BlockPointerType>(T)) {
2155 return STK_BlockPointer;
2156 } else if (isa<ObjCObjectPointerType>(T)) {
2157 return STK_ObjCObjectPointer;
2158 } else if (isa<MemberPointerType>(T)) {
2159 return STK_MemberPointer;
2160 } else if (isa<EnumType>(T)) {
2161 assert(cast<EnumType>(T)->getDecl()->isComplete());
2162 return STK_Integral;
2163 } else if (const auto *CT = dyn_cast<ComplexType>(T)) {
2164 if (CT->getElementType()->isRealFloatingType())
2165 return STK_FloatingComplex;
2166 return STK_IntegralComplex;
2167 } else if (isExtIntType()) {
2168 return STK_Integral;
2169 }
2170
2171 llvm_unreachable("unknown scalar type");
2172 }
2173
2174 /// Determines whether the type is a C++ aggregate type or C
2175 /// aggregate or union type.
2176 ///
2177 /// An aggregate type is an array or a class type (struct, union, or
2178 /// class) that has no user-declared constructors, no private or
2179 /// protected non-static data members, no base classes, and no virtual
2180 /// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type
2181 /// subsumes the notion of C aggregates (C99 6.2.5p21) because it also
2182 /// includes union types.
isAggregateType() const2183 bool Type::isAggregateType() const {
2184 if (const auto *Record = dyn_cast<RecordType>(CanonicalType)) {
2185 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl()))
2186 return ClassDecl->isAggregate();
2187
2188 return true;
2189 }
2190
2191 return isa<ArrayType>(CanonicalType);
2192 }
2193
2194 /// isConstantSizeType - Return true if this is not a variable sized type,
2195 /// according to the rules of C99 6.7.5p3. It is not legal to call this on
2196 /// incomplete types or dependent types.
isConstantSizeType() const2197 bool Type::isConstantSizeType() const {
2198 assert(!isIncompleteType() && "This doesn't make sense for incomplete types");
2199 assert(!isDependentType() && "This doesn't make sense for dependent types");
2200 // The VAT must have a size, as it is known to be complete.
2201 return !isa<VariableArrayType>(CanonicalType);
2202 }
2203
2204 /// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1)
2205 /// - a type that can describe objects, but which lacks information needed to
2206 /// determine its size.
isIncompleteType(NamedDecl ** Def) const2207 bool Type::isIncompleteType(NamedDecl **Def) const {
2208 if (Def)
2209 *Def = nullptr;
2210
2211 switch (CanonicalType->getTypeClass()) {
2212 default: return false;
2213 case Builtin:
2214 // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never
2215 // be completed.
2216 return isVoidType();
2217 case Enum: {
2218 EnumDecl *EnumD = cast<EnumType>(CanonicalType)->getDecl();
2219 if (Def)
2220 *Def = EnumD;
2221 return !EnumD->isComplete();
2222 }
2223 case Record: {
2224 // A tagged type (struct/union/enum/class) is incomplete if the decl is a
2225 // forward declaration, but not a full definition (C99 6.2.5p22).
2226 RecordDecl *Rec = cast<RecordType>(CanonicalType)->getDecl();
2227 if (Def)
2228 *Def = Rec;
2229 return !Rec->isCompleteDefinition();
2230 }
2231 case ConstantArray:
2232 case VariableArray:
2233 // An array is incomplete if its element type is incomplete
2234 // (C++ [dcl.array]p1).
2235 // We don't handle dependent-sized arrays (dependent types are never treated
2236 // as incomplete).
2237 return cast<ArrayType>(CanonicalType)->getElementType()
2238 ->isIncompleteType(Def);
2239 case IncompleteArray:
2240 // An array of unknown size is an incomplete type (C99 6.2.5p22).
2241 return true;
2242 case MemberPointer: {
2243 // Member pointers in the MS ABI have special behavior in
2244 // RequireCompleteType: they attach a MSInheritanceAttr to the CXXRecordDecl
2245 // to indicate which inheritance model to use.
2246 auto *MPTy = cast<MemberPointerType>(CanonicalType);
2247 const Type *ClassTy = MPTy->getClass();
2248 // Member pointers with dependent class types don't get special treatment.
2249 if (ClassTy->isDependentType())
2250 return false;
2251 const CXXRecordDecl *RD = ClassTy->getAsCXXRecordDecl();
2252 ASTContext &Context = RD->getASTContext();
2253 // Member pointers not in the MS ABI don't get special treatment.
2254 if (!Context.getTargetInfo().getCXXABI().isMicrosoft())
2255 return false;
2256 // The inheritance attribute might only be present on the most recent
2257 // CXXRecordDecl, use that one.
2258 RD = RD->getMostRecentNonInjectedDecl();
2259 // Nothing interesting to do if the inheritance attribute is already set.
2260 if (RD->hasAttr<MSInheritanceAttr>())
2261 return false;
2262 return true;
2263 }
2264 case ObjCObject:
2265 return cast<ObjCObjectType>(CanonicalType)->getBaseType()
2266 ->isIncompleteType(Def);
2267 case ObjCInterface: {
2268 // ObjC interfaces are incomplete if they are @class, not @interface.
2269 ObjCInterfaceDecl *Interface
2270 = cast<ObjCInterfaceType>(CanonicalType)->getDecl();
2271 if (Def)
2272 *Def = Interface;
2273 return !Interface->hasDefinition();
2274 }
2275 }
2276 }
2277
isSizelessBuiltinType() const2278 bool Type::isSizelessBuiltinType() const {
2279 if (const BuiltinType *BT = getAs<BuiltinType>()) {
2280 switch (BT->getKind()) {
2281 // SVE Types
2282 #define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2283 #include "clang/Basic/AArch64SVEACLETypes.def"
2284 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2285 #include "clang/Basic/RISCVVTypes.def"
2286 return true;
2287 default:
2288 return false;
2289 }
2290 }
2291 return false;
2292 }
2293
isSizelessType() const2294 bool Type::isSizelessType() const { return isSizelessBuiltinType(); }
2295
isVLSTBuiltinType() const2296 bool Type::isVLSTBuiltinType() const {
2297 if (const BuiltinType *BT = getAs<BuiltinType>()) {
2298 switch (BT->getKind()) {
2299 case BuiltinType::SveInt8:
2300 case BuiltinType::SveInt16:
2301 case BuiltinType::SveInt32:
2302 case BuiltinType::SveInt64:
2303 case BuiltinType::SveUint8:
2304 case BuiltinType::SveUint16:
2305 case BuiltinType::SveUint32:
2306 case BuiltinType::SveUint64:
2307 case BuiltinType::SveFloat16:
2308 case BuiltinType::SveFloat32:
2309 case BuiltinType::SveFloat64:
2310 case BuiltinType::SveBFloat16:
2311 case BuiltinType::SveBool:
2312 return true;
2313 default:
2314 return false;
2315 }
2316 }
2317 return false;
2318 }
2319
getSveEltType(const ASTContext & Ctx) const2320 QualType Type::getSveEltType(const ASTContext &Ctx) const {
2321 assert(isVLSTBuiltinType() && "unsupported type!");
2322
2323 const BuiltinType *BTy = getAs<BuiltinType>();
2324 if (BTy->getKind() == BuiltinType::SveBool)
2325 // Represent predicates as i8 rather than i1 to avoid any layout issues.
2326 // The type is bitcasted to a scalable predicate type when casting between
2327 // scalable and fixed-length vectors.
2328 return Ctx.UnsignedCharTy;
2329 else
2330 return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType;
2331 }
2332
isPODType(const ASTContext & Context) const2333 bool QualType::isPODType(const ASTContext &Context) const {
2334 // C++11 has a more relaxed definition of POD.
2335 if (Context.getLangOpts().CPlusPlus11)
2336 return isCXX11PODType(Context);
2337
2338 return isCXX98PODType(Context);
2339 }
2340
isCXX98PODType(const ASTContext & Context) const2341 bool QualType::isCXX98PODType(const ASTContext &Context) const {
2342 // The compiler shouldn't query this for incomplete types, but the user might.
2343 // We return false for that case. Except for incomplete arrays of PODs, which
2344 // are PODs according to the standard.
2345 if (isNull())
2346 return false;
2347
2348 if ((*this)->isIncompleteArrayType())
2349 return Context.getBaseElementType(*this).isCXX98PODType(Context);
2350
2351 if ((*this)->isIncompleteType())
2352 return false;
2353
2354 if (hasNonTrivialObjCLifetime())
2355 return false;
2356
2357 QualType CanonicalType = getTypePtr()->CanonicalType;
2358 switch (CanonicalType->getTypeClass()) {
2359 // Everything not explicitly mentioned is not POD.
2360 default: return false;
2361 case Type::VariableArray:
2362 case Type::ConstantArray:
2363 // IncompleteArray is handled above.
2364 return Context.getBaseElementType(*this).isCXX98PODType(Context);
2365
2366 case Type::ObjCObjectPointer:
2367 case Type::BlockPointer:
2368 case Type::Builtin:
2369 case Type::Complex:
2370 case Type::Pointer:
2371 case Type::MemberPointer:
2372 case Type::Vector:
2373 case Type::ExtVector:
2374 case Type::ExtInt:
2375 return true;
2376
2377 case Type::Enum:
2378 return true;
2379
2380 case Type::Record:
2381 if (const auto *ClassDecl =
2382 dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl()))
2383 return ClassDecl->isPOD();
2384
2385 // C struct/union is POD.
2386 return true;
2387 }
2388 }
2389
isTrivialType(const ASTContext & Context) const2390 bool QualType::isTrivialType(const ASTContext &Context) const {
2391 // The compiler shouldn't query this for incomplete types, but the user might.
2392 // We return false for that case. Except for incomplete arrays of PODs, which
2393 // are PODs according to the standard.
2394 if (isNull())
2395 return false;
2396
2397 if ((*this)->isArrayType())
2398 return Context.getBaseElementType(*this).isTrivialType(Context);
2399
2400 if ((*this)->isSizelessBuiltinType())
2401 return true;
2402
2403 // Return false for incomplete types after skipping any incomplete array
2404 // types which are expressly allowed by the standard and thus our API.
2405 if ((*this)->isIncompleteType())
2406 return false;
2407
2408 if (hasNonTrivialObjCLifetime())
2409 return false;
2410
2411 QualType CanonicalType = getTypePtr()->CanonicalType;
2412 if (CanonicalType->isDependentType())
2413 return false;
2414
2415 // C++0x [basic.types]p9:
2416 // Scalar types, trivial class types, arrays of such types, and
2417 // cv-qualified versions of these types are collectively called trivial
2418 // types.
2419
2420 // As an extension, Clang treats vector types as Scalar types.
2421 if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
2422 return true;
2423 if (const auto *RT = CanonicalType->getAs<RecordType>()) {
2424 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2425 // C++11 [class]p6:
2426 // A trivial class is a class that has a default constructor,
2427 // has no non-trivial default constructors, and is trivially
2428 // copyable.
2429 return ClassDecl->hasDefaultConstructor() &&
2430 !ClassDecl->hasNonTrivialDefaultConstructor() &&
2431 ClassDecl->isTriviallyCopyable();
2432 }
2433
2434 return true;
2435 }
2436
2437 // No other types can match.
2438 return false;
2439 }
2440
isTriviallyCopyableType(const ASTContext & Context) const2441 bool QualType::isTriviallyCopyableType(const ASTContext &Context) const {
2442 if ((*this)->isArrayType())
2443 return Context.getBaseElementType(*this).isTriviallyCopyableType(Context);
2444
2445 if (hasNonTrivialObjCLifetime())
2446 return false;
2447
2448 // C++11 [basic.types]p9 - See Core 2094
2449 // Scalar types, trivially copyable class types, arrays of such types, and
2450 // cv-qualified versions of these types are collectively
2451 // called trivially copyable types.
2452
2453 QualType CanonicalType = getCanonicalType();
2454 if (CanonicalType->isDependentType())
2455 return false;
2456
2457 if (CanonicalType->isSizelessBuiltinType())
2458 return true;
2459
2460 // Return false for incomplete types after skipping any incomplete array types
2461 // which are expressly allowed by the standard and thus our API.
2462 if (CanonicalType->isIncompleteType())
2463 return false;
2464
2465 // As an extension, Clang treats vector types as Scalar types.
2466 if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
2467 return true;
2468
2469 if (const auto *RT = CanonicalType->getAs<RecordType>()) {
2470 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2471 if (!ClassDecl->isTriviallyCopyable()) return false;
2472 }
2473
2474 return true;
2475 }
2476
2477 // No other types can match.
2478 return false;
2479 }
2480
isNonWeakInMRRWithObjCWeak(const ASTContext & Context) const2481 bool QualType::isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const {
2482 return !Context.getLangOpts().ObjCAutoRefCount &&
2483 Context.getLangOpts().ObjCWeak &&
2484 getObjCLifetime() != Qualifiers::OCL_Weak;
2485 }
2486
hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl * RD)2487 bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD) {
2488 return RD->hasNonTrivialToPrimitiveDefaultInitializeCUnion();
2489 }
2490
hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl * RD)2491 bool QualType::hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD) {
2492 return RD->hasNonTrivialToPrimitiveDestructCUnion();
2493 }
2494
hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl * RD)2495 bool QualType::hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD) {
2496 return RD->hasNonTrivialToPrimitiveCopyCUnion();
2497 }
2498
2499 QualType::PrimitiveDefaultInitializeKind
isNonTrivialToPrimitiveDefaultInitialize() const2500 QualType::isNonTrivialToPrimitiveDefaultInitialize() const {
2501 if (const auto *RT =
2502 getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>())
2503 if (RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize())
2504 return PDIK_Struct;
2505
2506 switch (getQualifiers().getObjCLifetime()) {
2507 case Qualifiers::OCL_Strong:
2508 return PDIK_ARCStrong;
2509 case Qualifiers::OCL_Weak:
2510 return PDIK_ARCWeak;
2511 default:
2512 return PDIK_Trivial;
2513 }
2514 }
2515
isNonTrivialToPrimitiveCopy() const2516 QualType::PrimitiveCopyKind QualType::isNonTrivialToPrimitiveCopy() const {
2517 if (const auto *RT =
2518 getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>())
2519 if (RT->getDecl()->isNonTrivialToPrimitiveCopy())
2520 return PCK_Struct;
2521
2522 Qualifiers Qs = getQualifiers();
2523 switch (Qs.getObjCLifetime()) {
2524 case Qualifiers::OCL_Strong:
2525 return PCK_ARCStrong;
2526 case Qualifiers::OCL_Weak:
2527 return PCK_ARCWeak;
2528 default:
2529 return Qs.hasVolatile() ? PCK_VolatileTrivial : PCK_Trivial;
2530 }
2531 }
2532
2533 QualType::PrimitiveCopyKind
isNonTrivialToPrimitiveDestructiveMove() const2534 QualType::isNonTrivialToPrimitiveDestructiveMove() const {
2535 return isNonTrivialToPrimitiveCopy();
2536 }
2537
isLiteralType(const ASTContext & Ctx) const2538 bool Type::isLiteralType(const ASTContext &Ctx) const {
2539 if (isDependentType())
2540 return false;
2541
2542 // C++1y [basic.types]p10:
2543 // A type is a literal type if it is:
2544 // -- cv void; or
2545 if (Ctx.getLangOpts().CPlusPlus14 && isVoidType())
2546 return true;
2547
2548 // C++11 [basic.types]p10:
2549 // A type is a literal type if it is:
2550 // [...]
2551 // -- an array of literal type other than an array of runtime bound; or
2552 if (isVariableArrayType())
2553 return false;
2554 const Type *BaseTy = getBaseElementTypeUnsafe();
2555 assert(BaseTy && "NULL element type");
2556
2557 // Return false for incomplete types after skipping any incomplete array
2558 // types; those are expressly allowed by the standard and thus our API.
2559 if (BaseTy->isIncompleteType())
2560 return false;
2561
2562 // C++11 [basic.types]p10:
2563 // A type is a literal type if it is:
2564 // -- a scalar type; or
2565 // As an extension, Clang treats vector types and complex types as
2566 // literal types.
2567 if (BaseTy->isScalarType() || BaseTy->isVectorType() ||
2568 BaseTy->isAnyComplexType())
2569 return true;
2570 // -- a reference type; or
2571 if (BaseTy->isReferenceType())
2572 return true;
2573 // -- a class type that has all of the following properties:
2574 if (const auto *RT = BaseTy->getAs<RecordType>()) {
2575 // -- a trivial destructor,
2576 // -- every constructor call and full-expression in the
2577 // brace-or-equal-initializers for non-static data members (if any)
2578 // is a constant expression,
2579 // -- it is an aggregate type or has at least one constexpr
2580 // constructor or constructor template that is not a copy or move
2581 // constructor, and
2582 // -- all non-static data members and base classes of literal types
2583 //
2584 // We resolve DR1361 by ignoring the second bullet.
2585 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2586 return ClassDecl->isLiteral();
2587
2588 return true;
2589 }
2590
2591 // We treat _Atomic T as a literal type if T is a literal type.
2592 if (const auto *AT = BaseTy->getAs<AtomicType>())
2593 return AT->getValueType()->isLiteralType(Ctx);
2594
2595 // If this type hasn't been deduced yet, then conservatively assume that
2596 // it'll work out to be a literal type.
2597 if (isa<AutoType>(BaseTy->getCanonicalTypeInternal()))
2598 return true;
2599
2600 return false;
2601 }
2602
isStructuralType() const2603 bool Type::isStructuralType() const {
2604 // C++20 [temp.param]p6:
2605 // A structural type is one of the following:
2606 // -- a scalar type; or
2607 // -- a vector type [Clang extension]; or
2608 if (isScalarType() || isVectorType())
2609 return true;
2610 // -- an lvalue reference type; or
2611 if (isLValueReferenceType())
2612 return true;
2613 // -- a literal class type [...under some conditions]
2614 if (const CXXRecordDecl *RD = getAsCXXRecordDecl())
2615 return RD->isStructural();
2616 return false;
2617 }
2618
isStandardLayoutType() const2619 bool Type::isStandardLayoutType() const {
2620 if (isDependentType())
2621 return false;
2622
2623 // C++0x [basic.types]p9:
2624 // Scalar types, standard-layout class types, arrays of such types, and
2625 // cv-qualified versions of these types are collectively called
2626 // standard-layout types.
2627 const Type *BaseTy = getBaseElementTypeUnsafe();
2628 assert(BaseTy && "NULL element type");
2629
2630 // Return false for incomplete types after skipping any incomplete array
2631 // types which are expressly allowed by the standard and thus our API.
2632 if (BaseTy->isIncompleteType())
2633 return false;
2634
2635 // As an extension, Clang treats vector types as Scalar types.
2636 if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
2637 if (const auto *RT = BaseTy->getAs<RecordType>()) {
2638 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2639 if (!ClassDecl->isStandardLayout())
2640 return false;
2641
2642 // Default to 'true' for non-C++ class types.
2643 // FIXME: This is a bit dubious, but plain C structs should trivially meet
2644 // all the requirements of standard layout classes.
2645 return true;
2646 }
2647
2648 // No other types can match.
2649 return false;
2650 }
2651
2652 // This is effectively the intersection of isTrivialType and
2653 // isStandardLayoutType. We implement it directly to avoid redundant
2654 // conversions from a type to a CXXRecordDecl.
isCXX11PODType(const ASTContext & Context) const2655 bool QualType::isCXX11PODType(const ASTContext &Context) const {
2656 const Type *ty = getTypePtr();
2657 if (ty->isDependentType())
2658 return false;
2659
2660 if (hasNonTrivialObjCLifetime())
2661 return false;
2662
2663 // C++11 [basic.types]p9:
2664 // Scalar types, POD classes, arrays of such types, and cv-qualified
2665 // versions of these types are collectively called trivial types.
2666 const Type *BaseTy = ty->getBaseElementTypeUnsafe();
2667 assert(BaseTy && "NULL element type");
2668
2669 if (BaseTy->isSizelessBuiltinType())
2670 return true;
2671
2672 // Return false for incomplete types after skipping any incomplete array
2673 // types which are expressly allowed by the standard and thus our API.
2674 if (BaseTy->isIncompleteType())
2675 return false;
2676
2677 // As an extension, Clang treats vector types as Scalar types.
2678 if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
2679 if (const auto *RT = BaseTy->getAs<RecordType>()) {
2680 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2681 // C++11 [class]p10:
2682 // A POD struct is a non-union class that is both a trivial class [...]
2683 if (!ClassDecl->isTrivial()) return false;
2684
2685 // C++11 [class]p10:
2686 // A POD struct is a non-union class that is both a trivial class and
2687 // a standard-layout class [...]
2688 if (!ClassDecl->isStandardLayout()) return false;
2689
2690 // C++11 [class]p10:
2691 // A POD struct is a non-union class that is both a trivial class and
2692 // a standard-layout class, and has no non-static data members of type
2693 // non-POD struct, non-POD union (or array of such types). [...]
2694 //
2695 // We don't directly query the recursive aspect as the requirements for
2696 // both standard-layout classes and trivial classes apply recursively
2697 // already.
2698 }
2699
2700 return true;
2701 }
2702
2703 // No other types can match.
2704 return false;
2705 }
2706
isNothrowT() const2707 bool Type::isNothrowT() const {
2708 if (const auto *RD = getAsCXXRecordDecl()) {
2709 IdentifierInfo *II = RD->getIdentifier();
2710 if (II && II->isStr("nothrow_t") && RD->isInStdNamespace())
2711 return true;
2712 }
2713 return false;
2714 }
2715
isAlignValT() const2716 bool Type::isAlignValT() const {
2717 if (const auto *ET = getAs<EnumType>()) {
2718 IdentifierInfo *II = ET->getDecl()->getIdentifier();
2719 if (II && II->isStr("align_val_t") && ET->getDecl()->isInStdNamespace())
2720 return true;
2721 }
2722 return false;
2723 }
2724
isStdByteType() const2725 bool Type::isStdByteType() const {
2726 if (const auto *ET = getAs<EnumType>()) {
2727 IdentifierInfo *II = ET->getDecl()->getIdentifier();
2728 if (II && II->isStr("byte") && ET->getDecl()->isInStdNamespace())
2729 return true;
2730 }
2731 return false;
2732 }
2733
isPromotableIntegerType() const2734 bool Type::isPromotableIntegerType() const {
2735 if (const auto *BT = getAs<BuiltinType>())
2736 switch (BT->getKind()) {
2737 case BuiltinType::Bool:
2738 case BuiltinType::Char_S:
2739 case BuiltinType::Char_U:
2740 case BuiltinType::SChar:
2741 case BuiltinType::UChar:
2742 case BuiltinType::Short:
2743 case BuiltinType::UShort:
2744 case BuiltinType::WChar_S:
2745 case BuiltinType::WChar_U:
2746 case BuiltinType::Char8:
2747 case BuiltinType::Char16:
2748 case BuiltinType::Char32:
2749 return true;
2750 default:
2751 return false;
2752 }
2753
2754 // Enumerated types are promotable to their compatible integer types
2755 // (C99 6.3.1.1) a.k.a. its underlying type (C++ [conv.prom]p2).
2756 if (const auto *ET = getAs<EnumType>()){
2757 if (this->isDependentType() || ET->getDecl()->getPromotionType().isNull()
2758 || ET->getDecl()->isScoped())
2759 return false;
2760
2761 return true;
2762 }
2763
2764 return false;
2765 }
2766
isSpecifierType() const2767 bool Type::isSpecifierType() const {
2768 // Note that this intentionally does not use the canonical type.
2769 switch (getTypeClass()) {
2770 case Builtin:
2771 case Record:
2772 case Enum:
2773 case Typedef:
2774 case Complex:
2775 case TypeOfExpr:
2776 case TypeOf:
2777 case TemplateTypeParm:
2778 case SubstTemplateTypeParm:
2779 case TemplateSpecialization:
2780 case Elaborated:
2781 case DependentName:
2782 case DependentTemplateSpecialization:
2783 case ObjCInterface:
2784 case ObjCObject:
2785 case ObjCObjectPointer: // FIXME: object pointers aren't really specifiers
2786 return true;
2787 default:
2788 return false;
2789 }
2790 }
2791
2792 ElaboratedTypeKeyword
getKeywordForTypeSpec(unsigned TypeSpec)2793 TypeWithKeyword::getKeywordForTypeSpec(unsigned TypeSpec) {
2794 switch (TypeSpec) {
2795 default: return ETK_None;
2796 case TST_typename: return ETK_Typename;
2797 case TST_class: return ETK_Class;
2798 case TST_struct: return ETK_Struct;
2799 case TST_interface: return ETK_Interface;
2800 case TST_union: return ETK_Union;
2801 case TST_enum: return ETK_Enum;
2802 }
2803 }
2804
2805 TagTypeKind
getTagTypeKindForTypeSpec(unsigned TypeSpec)2806 TypeWithKeyword::getTagTypeKindForTypeSpec(unsigned TypeSpec) {
2807 switch(TypeSpec) {
2808 case TST_class: return TTK_Class;
2809 case TST_struct: return TTK_Struct;
2810 case TST_interface: return TTK_Interface;
2811 case TST_union: return TTK_Union;
2812 case TST_enum: return TTK_Enum;
2813 }
2814
2815 llvm_unreachable("Type specifier is not a tag type kind.");
2816 }
2817
2818 ElaboratedTypeKeyword
getKeywordForTagTypeKind(TagTypeKind Kind)2819 TypeWithKeyword::getKeywordForTagTypeKind(TagTypeKind Kind) {
2820 switch (Kind) {
2821 case TTK_Class: return ETK_Class;
2822 case TTK_Struct: return ETK_Struct;
2823 case TTK_Interface: return ETK_Interface;
2824 case TTK_Union: return ETK_Union;
2825 case TTK_Enum: return ETK_Enum;
2826 }
2827 llvm_unreachable("Unknown tag type kind.");
2828 }
2829
2830 TagTypeKind
getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)2831 TypeWithKeyword::getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword) {
2832 switch (Keyword) {
2833 case ETK_Class: return TTK_Class;
2834 case ETK_Struct: return TTK_Struct;
2835 case ETK_Interface: return TTK_Interface;
2836 case ETK_Union: return TTK_Union;
2837 case ETK_Enum: return TTK_Enum;
2838 case ETK_None: // Fall through.
2839 case ETK_Typename:
2840 llvm_unreachable("Elaborated type keyword is not a tag type kind.");
2841 }
2842 llvm_unreachable("Unknown elaborated type keyword.");
2843 }
2844
2845 bool
KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword)2846 TypeWithKeyword::KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword) {
2847 switch (Keyword) {
2848 case ETK_None:
2849 case ETK_Typename:
2850 return false;
2851 case ETK_Class:
2852 case ETK_Struct:
2853 case ETK_Interface:
2854 case ETK_Union:
2855 case ETK_Enum:
2856 return true;
2857 }
2858 llvm_unreachable("Unknown elaborated type keyword.");
2859 }
2860
getKeywordName(ElaboratedTypeKeyword Keyword)2861 StringRef TypeWithKeyword::getKeywordName(ElaboratedTypeKeyword Keyword) {
2862 switch (Keyword) {
2863 case ETK_None: return {};
2864 case ETK_Typename: return "typename";
2865 case ETK_Class: return "class";
2866 case ETK_Struct: return "struct";
2867 case ETK_Interface: return "__interface";
2868 case ETK_Union: return "union";
2869 case ETK_Enum: return "enum";
2870 }
2871
2872 llvm_unreachable("Unknown elaborated type keyword.");
2873 }
2874
DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,NestedNameSpecifier * NNS,const IdentifierInfo * Name,ArrayRef<TemplateArgument> Args,QualType Canon)2875 DependentTemplateSpecializationType::DependentTemplateSpecializationType(
2876 ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
2877 const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args, QualType Canon)
2878 : TypeWithKeyword(Keyword, DependentTemplateSpecialization, Canon,
2879 TypeDependence::DependentInstantiation |
2880 (NNS ? toTypeDependence(NNS->getDependence())
2881 : TypeDependence::None)),
2882 NNS(NNS), Name(Name) {
2883 DependentTemplateSpecializationTypeBits.NumArgs = Args.size();
2884 assert((!NNS || NNS->isDependent()) &&
2885 "DependentTemplateSpecializatonType requires dependent qualifier");
2886 TemplateArgument *ArgBuffer = getArgBuffer();
2887 for (const TemplateArgument &Arg : Args) {
2888 addDependence(toTypeDependence(Arg.getDependence() &
2889 TemplateArgumentDependence::UnexpandedPack));
2890
2891 new (ArgBuffer++) TemplateArgument(Arg);
2892 }
2893 }
2894
2895 void
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,ElaboratedTypeKeyword Keyword,NestedNameSpecifier * Qualifier,const IdentifierInfo * Name,ArrayRef<TemplateArgument> Args)2896 DependentTemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
2897 const ASTContext &Context,
2898 ElaboratedTypeKeyword Keyword,
2899 NestedNameSpecifier *Qualifier,
2900 const IdentifierInfo *Name,
2901 ArrayRef<TemplateArgument> Args) {
2902 ID.AddInteger(Keyword);
2903 ID.AddPointer(Qualifier);
2904 ID.AddPointer(Name);
2905 for (const TemplateArgument &Arg : Args)
2906 Arg.Profile(ID, Context);
2907 }
2908
isElaboratedTypeSpecifier() const2909 bool Type::isElaboratedTypeSpecifier() const {
2910 ElaboratedTypeKeyword Keyword;
2911 if (const auto *Elab = dyn_cast<ElaboratedType>(this))
2912 Keyword = Elab->getKeyword();
2913 else if (const auto *DepName = dyn_cast<DependentNameType>(this))
2914 Keyword = DepName->getKeyword();
2915 else if (const auto *DepTST =
2916 dyn_cast<DependentTemplateSpecializationType>(this))
2917 Keyword = DepTST->getKeyword();
2918 else
2919 return false;
2920
2921 return TypeWithKeyword::KeywordIsTagTypeKind(Keyword);
2922 }
2923
getTypeClassName() const2924 const char *Type::getTypeClassName() const {
2925 switch (TypeBits.TC) {
2926 #define ABSTRACT_TYPE(Derived, Base)
2927 #define TYPE(Derived, Base) case Derived: return #Derived;
2928 #include "clang/AST/TypeNodes.inc"
2929 }
2930
2931 llvm_unreachable("Invalid type class.");
2932 }
2933
getName(const PrintingPolicy & Policy) const2934 StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
2935 switch (getKind()) {
2936 case Void:
2937 return "void";
2938 case Bool:
2939 return Policy.Bool ? "bool" : "_Bool";
2940 case Char_S:
2941 return "char";
2942 case Char_U:
2943 return "char";
2944 case SChar:
2945 return "signed char";
2946 case Short:
2947 return "short";
2948 case Int:
2949 return "int";
2950 case Long:
2951 return "long";
2952 case LongLong:
2953 return "long long";
2954 case Int128:
2955 return "__int128";
2956 case UChar:
2957 return "unsigned char";
2958 case UShort:
2959 return "unsigned short";
2960 case UInt:
2961 return "unsigned int";
2962 case ULong:
2963 return "unsigned long";
2964 case ULongLong:
2965 return "unsigned long long";
2966 case UInt128:
2967 return "unsigned __int128";
2968 case Half:
2969 return Policy.Half ? "half" : "__fp16";
2970 case BFloat16:
2971 return "__bf16";
2972 case Float:
2973 return "float";
2974 case Double:
2975 return "double";
2976 case LongDouble:
2977 return "long double";
2978 case ShortAccum:
2979 return "short _Accum";
2980 case Accum:
2981 return "_Accum";
2982 case LongAccum:
2983 return "long _Accum";
2984 case UShortAccum:
2985 return "unsigned short _Accum";
2986 case UAccum:
2987 return "unsigned _Accum";
2988 case ULongAccum:
2989 return "unsigned long _Accum";
2990 case BuiltinType::ShortFract:
2991 return "short _Fract";
2992 case BuiltinType::Fract:
2993 return "_Fract";
2994 case BuiltinType::LongFract:
2995 return "long _Fract";
2996 case BuiltinType::UShortFract:
2997 return "unsigned short _Fract";
2998 case BuiltinType::UFract:
2999 return "unsigned _Fract";
3000 case BuiltinType::ULongFract:
3001 return "unsigned long _Fract";
3002 case BuiltinType::SatShortAccum:
3003 return "_Sat short _Accum";
3004 case BuiltinType::SatAccum:
3005 return "_Sat _Accum";
3006 case BuiltinType::SatLongAccum:
3007 return "_Sat long _Accum";
3008 case BuiltinType::SatUShortAccum:
3009 return "_Sat unsigned short _Accum";
3010 case BuiltinType::SatUAccum:
3011 return "_Sat unsigned _Accum";
3012 case BuiltinType::SatULongAccum:
3013 return "_Sat unsigned long _Accum";
3014 case BuiltinType::SatShortFract:
3015 return "_Sat short _Fract";
3016 case BuiltinType::SatFract:
3017 return "_Sat _Fract";
3018 case BuiltinType::SatLongFract:
3019 return "_Sat long _Fract";
3020 case BuiltinType::SatUShortFract:
3021 return "_Sat unsigned short _Fract";
3022 case BuiltinType::SatUFract:
3023 return "_Sat unsigned _Fract";
3024 case BuiltinType::SatULongFract:
3025 return "_Sat unsigned long _Fract";
3026 case Float16:
3027 return "_Float16";
3028 case Float128:
3029 return "__float128";
3030 case WChar_S:
3031 case WChar_U:
3032 return Policy.MSWChar ? "__wchar_t" : "wchar_t";
3033 case Char8:
3034 return "char8_t";
3035 case Char16:
3036 return "char16_t";
3037 case Char32:
3038 return "char32_t";
3039 case NullPtr:
3040 return "nullptr_t";
3041 case Overload:
3042 return "<overloaded function type>";
3043 case BoundMember:
3044 return "<bound member function type>";
3045 case PseudoObject:
3046 return "<pseudo-object type>";
3047 case Dependent:
3048 return "<dependent type>";
3049 case UnknownAny:
3050 return "<unknown type>";
3051 case ARCUnbridgedCast:
3052 return "<ARC unbridged cast type>";
3053 case BuiltinFn:
3054 return "<builtin fn type>";
3055 case ObjCId:
3056 return "id";
3057 case ObjCClass:
3058 return "Class";
3059 case ObjCSel:
3060 return "SEL";
3061 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3062 case Id: \
3063 return "__" #Access " " #ImgType "_t";
3064 #include "clang/Basic/OpenCLImageTypes.def"
3065 case OCLSampler:
3066 return "sampler_t";
3067 case OCLEvent:
3068 return "event_t";
3069 case OCLClkEvent:
3070 return "clk_event_t";
3071 case OCLQueue:
3072 return "queue_t";
3073 case OCLReserveID:
3074 return "reserve_id_t";
3075 case IncompleteMatrixIdx:
3076 return "<incomplete matrix index type>";
3077 case OMPArraySection:
3078 return "<OpenMP array section type>";
3079 case OMPArrayShaping:
3080 return "<OpenMP array shaping type>";
3081 case OMPIterator:
3082 return "<OpenMP iterator type>";
3083 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
3084 case Id: \
3085 return #ExtType;
3086 #include "clang/Basic/OpenCLExtensionTypes.def"
3087 #define SVE_TYPE(Name, Id, SingletonId) \
3088 case Id: \
3089 return Name;
3090 #include "clang/Basic/AArch64SVEACLETypes.def"
3091 #define PPC_VECTOR_TYPE(Name, Id, Size) \
3092 case Id: \
3093 return #Name;
3094 #include "clang/Basic/PPCTypes.def"
3095 #define RVV_TYPE(Name, Id, SingletonId) \
3096 case Id: \
3097 return Name;
3098 #include "clang/Basic/RISCVVTypes.def"
3099 }
3100
3101 llvm_unreachable("Invalid builtin type.");
3102 }
3103
getNonPackExpansionType() const3104 QualType QualType::getNonPackExpansionType() const {
3105 // We never wrap type sugar around a PackExpansionType.
3106 if (auto *PET = dyn_cast<PackExpansionType>(getTypePtr()))
3107 return PET->getPattern();
3108 return *this;
3109 }
3110
getNonLValueExprType(const ASTContext & Context) const3111 QualType QualType::getNonLValueExprType(const ASTContext &Context) const {
3112 if (const auto *RefType = getTypePtr()->getAs<ReferenceType>())
3113 return RefType->getPointeeType();
3114
3115 // C++0x [basic.lval]:
3116 // Class prvalues can have cv-qualified types; non-class prvalues always
3117 // have cv-unqualified types.
3118 //
3119 // See also C99 6.3.2.1p2.
3120 if (!Context.getLangOpts().CPlusPlus ||
3121 (!getTypePtr()->isDependentType() && !getTypePtr()->isRecordType()))
3122 return getUnqualifiedType();
3123
3124 return *this;
3125 }
3126
getNameForCallConv(CallingConv CC)3127 StringRef FunctionType::getNameForCallConv(CallingConv CC) {
3128 switch (CC) {
3129 case CC_C: return "cdecl";
3130 case CC_X86StdCall: return "stdcall";
3131 case CC_X86FastCall: return "fastcall";
3132 case CC_X86ThisCall: return "thiscall";
3133 case CC_X86Pascal: return "pascal";
3134 case CC_X86VectorCall: return "vectorcall";
3135 case CC_Win64: return "ms_abi";
3136 case CC_X86_64SysV: return "sysv_abi";
3137 case CC_X86RegCall : return "regcall";
3138 case CC_AAPCS: return "aapcs";
3139 case CC_AAPCS_VFP: return "aapcs-vfp";
3140 case CC_AArch64VectorCall: return "aarch64_vector_pcs";
3141 case CC_IntelOclBicc: return "intel_ocl_bicc";
3142 case CC_SpirFunction: return "spir_function";
3143 case CC_OpenCLKernel: return "opencl_kernel";
3144 case CC_Swift: return "swiftcall";
3145 case CC_PreserveMost: return "preserve_most";
3146 case CC_PreserveAll: return "preserve_all";
3147 }
3148
3149 llvm_unreachable("Invalid calling convention.");
3150 }
3151
FunctionProtoType(QualType result,ArrayRef<QualType> params,QualType canonical,const ExtProtoInfo & epi)3152 FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
3153 QualType canonical,
3154 const ExtProtoInfo &epi)
3155 : FunctionType(FunctionProto, result, canonical, result->getDependence(),
3156 epi.ExtInfo) {
3157 FunctionTypeBits.FastTypeQuals = epi.TypeQuals.getFastQualifiers();
3158 FunctionTypeBits.RefQualifier = epi.RefQualifier;
3159 FunctionTypeBits.NumParams = params.size();
3160 assert(getNumParams() == params.size() && "NumParams overflow!");
3161 FunctionTypeBits.ExceptionSpecType = epi.ExceptionSpec.Type;
3162 FunctionTypeBits.HasExtParameterInfos = !!epi.ExtParameterInfos;
3163 FunctionTypeBits.Variadic = epi.Variadic;
3164 FunctionTypeBits.HasTrailingReturn = epi.HasTrailingReturn;
3165
3166 // Fill in the extra trailing bitfields if present.
3167 if (hasExtraBitfields(epi.ExceptionSpec.Type)) {
3168 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3169 ExtraBits.NumExceptionType = epi.ExceptionSpec.Exceptions.size();
3170 }
3171
3172 // Fill in the trailing argument array.
3173 auto *argSlot = getTrailingObjects<QualType>();
3174 for (unsigned i = 0; i != getNumParams(); ++i) {
3175 addDependence(params[i]->getDependence() &
3176 ~TypeDependence::VariablyModified);
3177 argSlot[i] = params[i];
3178 }
3179
3180 // Fill in the exception type array if present.
3181 if (getExceptionSpecType() == EST_Dynamic) {
3182 assert(hasExtraBitfields() && "missing trailing extra bitfields!");
3183 auto *exnSlot =
3184 reinterpret_cast<QualType *>(getTrailingObjects<ExceptionType>());
3185 unsigned I = 0;
3186 for (QualType ExceptionType : epi.ExceptionSpec.Exceptions) {
3187 // Note that, before C++17, a dependent exception specification does
3188 // *not* make a type dependent; it's not even part of the C++ type
3189 // system.
3190 addDependence(
3191 ExceptionType->getDependence() &
3192 (TypeDependence::Instantiation | TypeDependence::UnexpandedPack));
3193
3194 exnSlot[I++] = ExceptionType;
3195 }
3196 }
3197 // Fill in the Expr * in the exception specification if present.
3198 else if (isComputedNoexcept(getExceptionSpecType())) {
3199 assert(epi.ExceptionSpec.NoexceptExpr && "computed noexcept with no expr");
3200 assert((getExceptionSpecType() == EST_DependentNoexcept) ==
3201 epi.ExceptionSpec.NoexceptExpr->isValueDependent());
3202
3203 // Store the noexcept expression and context.
3204 *getTrailingObjects<Expr *>() = epi.ExceptionSpec.NoexceptExpr;
3205
3206 addDependence(
3207 toTypeDependence(epi.ExceptionSpec.NoexceptExpr->getDependence()) &
3208 (TypeDependence::Instantiation | TypeDependence::UnexpandedPack));
3209 }
3210 // Fill in the FunctionDecl * in the exception specification if present.
3211 else if (getExceptionSpecType() == EST_Uninstantiated) {
3212 // Store the function decl from which we will resolve our
3213 // exception specification.
3214 auto **slot = getTrailingObjects<FunctionDecl *>();
3215 slot[0] = epi.ExceptionSpec.SourceDecl;
3216 slot[1] = epi.ExceptionSpec.SourceTemplate;
3217 // This exception specification doesn't make the type dependent, because
3218 // it's not instantiated as part of instantiating the type.
3219 } else if (getExceptionSpecType() == EST_Unevaluated) {
3220 // Store the function decl from which we will resolve our
3221 // exception specification.
3222 auto **slot = getTrailingObjects<FunctionDecl *>();
3223 slot[0] = epi.ExceptionSpec.SourceDecl;
3224 }
3225
3226 // If this is a canonical type, and its exception specification is dependent,
3227 // then it's a dependent type. This only happens in C++17 onwards.
3228 if (isCanonicalUnqualified()) {
3229 if (getExceptionSpecType() == EST_Dynamic ||
3230 getExceptionSpecType() == EST_DependentNoexcept) {
3231 assert(hasDependentExceptionSpec() && "type should not be canonical");
3232 addDependence(TypeDependence::DependentInstantiation);
3233 }
3234 } else if (getCanonicalTypeInternal()->isDependentType()) {
3235 // Ask our canonical type whether our exception specification was dependent.
3236 addDependence(TypeDependence::DependentInstantiation);
3237 }
3238
3239 // Fill in the extra parameter info if present.
3240 if (epi.ExtParameterInfos) {
3241 auto *extParamInfos = getTrailingObjects<ExtParameterInfo>();
3242 for (unsigned i = 0; i != getNumParams(); ++i)
3243 extParamInfos[i] = epi.ExtParameterInfos[i];
3244 }
3245
3246 if (epi.TypeQuals.hasNonFastQualifiers()) {
3247 FunctionTypeBits.HasExtQuals = 1;
3248 *getTrailingObjects<Qualifiers>() = epi.TypeQuals;
3249 } else {
3250 FunctionTypeBits.HasExtQuals = 0;
3251 }
3252
3253 // Fill in the Ellipsis location info if present.
3254 if (epi.Variadic) {
3255 auto &EllipsisLoc = *getTrailingObjects<SourceLocation>();
3256 EllipsisLoc = epi.EllipsisLoc;
3257 }
3258 }
3259
hasDependentExceptionSpec() const3260 bool FunctionProtoType::hasDependentExceptionSpec() const {
3261 if (Expr *NE = getNoexceptExpr())
3262 return NE->isValueDependent();
3263 for (QualType ET : exceptions())
3264 // A pack expansion with a non-dependent pattern is still dependent,
3265 // because we don't know whether the pattern is in the exception spec
3266 // or not (that depends on whether the pack has 0 expansions).
3267 if (ET->isDependentType() || ET->getAs<PackExpansionType>())
3268 return true;
3269 return false;
3270 }
3271
hasInstantiationDependentExceptionSpec() const3272 bool FunctionProtoType::hasInstantiationDependentExceptionSpec() const {
3273 if (Expr *NE = getNoexceptExpr())
3274 return NE->isInstantiationDependent();
3275 for (QualType ET : exceptions())
3276 if (ET->isInstantiationDependentType())
3277 return true;
3278 return false;
3279 }
3280
canThrow() const3281 CanThrowResult FunctionProtoType::canThrow() const {
3282 switch (getExceptionSpecType()) {
3283 case EST_Unparsed:
3284 case EST_Unevaluated:
3285 case EST_Uninstantiated:
3286 llvm_unreachable("should not call this with unresolved exception specs");
3287
3288 case EST_DynamicNone:
3289 case EST_BasicNoexcept:
3290 case EST_NoexceptTrue:
3291 case EST_NoThrow:
3292 return CT_Cannot;
3293
3294 case EST_None:
3295 case EST_MSAny:
3296 case EST_NoexceptFalse:
3297 return CT_Can;
3298
3299 case EST_Dynamic:
3300 // A dynamic exception specification is throwing unless every exception
3301 // type is an (unexpanded) pack expansion type.
3302 for (unsigned I = 0; I != getNumExceptions(); ++I)
3303 if (!getExceptionType(I)->getAs<PackExpansionType>())
3304 return CT_Can;
3305 return CT_Dependent;
3306
3307 case EST_DependentNoexcept:
3308 return CT_Dependent;
3309 }
3310
3311 llvm_unreachable("unexpected exception specification kind");
3312 }
3313
isTemplateVariadic() const3314 bool FunctionProtoType::isTemplateVariadic() const {
3315 for (unsigned ArgIdx = getNumParams(); ArgIdx; --ArgIdx)
3316 if (isa<PackExpansionType>(getParamType(ArgIdx - 1)))
3317 return true;
3318
3319 return false;
3320 }
3321
Profile(llvm::FoldingSetNodeID & ID,QualType Result,const QualType * ArgTys,unsigned NumParams,const ExtProtoInfo & epi,const ASTContext & Context,bool Canonical)3322 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
3323 const QualType *ArgTys, unsigned NumParams,
3324 const ExtProtoInfo &epi,
3325 const ASTContext &Context, bool Canonical) {
3326 // We have to be careful not to get ambiguous profile encodings.
3327 // Note that valid type pointers are never ambiguous with anything else.
3328 //
3329 // The encoding grammar begins:
3330 // type type* bool int bool
3331 // If that final bool is true, then there is a section for the EH spec:
3332 // bool type*
3333 // This is followed by an optional "consumed argument" section of the
3334 // same length as the first type sequence:
3335 // bool*
3336 // Finally, we have the ext info and trailing return type flag:
3337 // int bool
3338 //
3339 // There is no ambiguity between the consumed arguments and an empty EH
3340 // spec because of the leading 'bool' which unambiguously indicates
3341 // whether the following bool is the EH spec or part of the arguments.
3342
3343 ID.AddPointer(Result.getAsOpaquePtr());
3344 for (unsigned i = 0; i != NumParams; ++i)
3345 ID.AddPointer(ArgTys[i].getAsOpaquePtr());
3346 // This method is relatively performance sensitive, so as a performance
3347 // shortcut, use one AddInteger call instead of four for the next four
3348 // fields.
3349 assert(!(unsigned(epi.Variadic) & ~1) &&
3350 !(unsigned(epi.RefQualifier) & ~3) &&
3351 !(unsigned(epi.ExceptionSpec.Type) & ~15) &&
3352 "Values larger than expected.");
3353 ID.AddInteger(unsigned(epi.Variadic) +
3354 (epi.RefQualifier << 1) +
3355 (epi.ExceptionSpec.Type << 3));
3356 ID.Add(epi.TypeQuals);
3357 if (epi.ExceptionSpec.Type == EST_Dynamic) {
3358 for (QualType Ex : epi.ExceptionSpec.Exceptions)
3359 ID.AddPointer(Ex.getAsOpaquePtr());
3360 } else if (isComputedNoexcept(epi.ExceptionSpec.Type)) {
3361 epi.ExceptionSpec.NoexceptExpr->Profile(ID, Context, Canonical);
3362 } else if (epi.ExceptionSpec.Type == EST_Uninstantiated ||
3363 epi.ExceptionSpec.Type == EST_Unevaluated) {
3364 ID.AddPointer(epi.ExceptionSpec.SourceDecl->getCanonicalDecl());
3365 }
3366 if (epi.ExtParameterInfos) {
3367 for (unsigned i = 0; i != NumParams; ++i)
3368 ID.AddInteger(epi.ExtParameterInfos[i].getOpaqueValue());
3369 }
3370 epi.ExtInfo.Profile(ID);
3371 ID.AddBoolean(epi.HasTrailingReturn);
3372 }
3373
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Ctx)3374 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID,
3375 const ASTContext &Ctx) {
3376 Profile(ID, getReturnType(), param_type_begin(), getNumParams(),
3377 getExtProtoInfo(), Ctx, isCanonicalUnqualified());
3378 }
3379
TypedefType(TypeClass tc,const TypedefNameDecl * D,QualType underlying,QualType can)3380 TypedefType::TypedefType(TypeClass tc, const TypedefNameDecl *D,
3381 QualType underlying, QualType can)
3382 : Type(tc, can, underlying->getDependence()),
3383 Decl(const_cast<TypedefNameDecl *>(D)) {
3384 assert(!isa<TypedefType>(can) && "Invalid canonical type");
3385 }
3386
desugar() const3387 QualType TypedefType::desugar() const {
3388 return getDecl()->getUnderlyingType();
3389 }
3390
desugar() const3391 QualType MacroQualifiedType::desugar() const { return getUnderlyingType(); }
3392
getModifiedType() const3393 QualType MacroQualifiedType::getModifiedType() const {
3394 // Step over MacroQualifiedTypes from the same macro to find the type
3395 // ultimately qualified by the macro qualifier.
3396 QualType Inner = cast<AttributedType>(getUnderlyingType())->getModifiedType();
3397 while (auto *InnerMQT = dyn_cast<MacroQualifiedType>(Inner)) {
3398 if (InnerMQT->getMacroIdentifier() != getMacroIdentifier())
3399 break;
3400 Inner = InnerMQT->getModifiedType();
3401 }
3402 return Inner;
3403 }
3404
TypeOfExprType(Expr * E,QualType can)3405 TypeOfExprType::TypeOfExprType(Expr *E, QualType can)
3406 : Type(TypeOfExpr, can,
3407 toTypeDependence(E->getDependence()) |
3408 (E->getType()->getDependence() &
3409 TypeDependence::VariablyModified)),
3410 TOExpr(E) {}
3411
isSugared() const3412 bool TypeOfExprType::isSugared() const {
3413 return !TOExpr->isTypeDependent();
3414 }
3415
desugar() const3416 QualType TypeOfExprType::desugar() const {
3417 if (isSugared())
3418 return getUnderlyingExpr()->getType();
3419
3420 return QualType(this, 0);
3421 }
3422
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,Expr * E)3423 void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID,
3424 const ASTContext &Context, Expr *E) {
3425 E->Profile(ID, Context, true);
3426 }
3427
DecltypeType(Expr * E,QualType underlyingType,QualType can)3428 DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can)
3429 // C++11 [temp.type]p2: "If an expression e involves a template parameter,
3430 // decltype(e) denotes a unique dependent type." Hence a decltype type is
3431 // type-dependent even if its expression is only instantiation-dependent.
3432 : Type(Decltype, can,
3433 toTypeDependence(E->getDependence()) |
3434 (E->isInstantiationDependent() ? TypeDependence::Dependent
3435 : TypeDependence::None) |
3436 (E->getType()->getDependence() &
3437 TypeDependence::VariablyModified)),
3438 E(E), UnderlyingType(underlyingType) {}
3439
isSugared() const3440 bool DecltypeType::isSugared() const { return !E->isInstantiationDependent(); }
3441
desugar() const3442 QualType DecltypeType::desugar() const {
3443 if (isSugared())
3444 return getUnderlyingType();
3445
3446 return QualType(this, 0);
3447 }
3448
DependentDecltypeType(const ASTContext & Context,Expr * E)3449 DependentDecltypeType::DependentDecltypeType(const ASTContext &Context, Expr *E)
3450 : DecltypeType(E, Context.DependentTy), Context(Context) {}
3451
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,Expr * E)3452 void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
3453 const ASTContext &Context, Expr *E) {
3454 E->Profile(ID, Context, true);
3455 }
3456
UnaryTransformType(QualType BaseType,QualType UnderlyingType,UTTKind UKind,QualType CanonicalType)3457 UnaryTransformType::UnaryTransformType(QualType BaseType,
3458 QualType UnderlyingType, UTTKind UKind,
3459 QualType CanonicalType)
3460 : Type(UnaryTransform, CanonicalType, BaseType->getDependence()),
3461 BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) {}
3462
DependentUnaryTransformType(const ASTContext & C,QualType BaseType,UTTKind UKind)3463 DependentUnaryTransformType::DependentUnaryTransformType(const ASTContext &C,
3464 QualType BaseType,
3465 UTTKind UKind)
3466 : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType()) {}
3467
TagType(TypeClass TC,const TagDecl * D,QualType can)3468 TagType::TagType(TypeClass TC, const TagDecl *D, QualType can)
3469 : Type(TC, can,
3470 D->isDependentType() ? TypeDependence::DependentInstantiation
3471 : TypeDependence::None),
3472 decl(const_cast<TagDecl *>(D)) {}
3473
getInterestingTagDecl(TagDecl * decl)3474 static TagDecl *getInterestingTagDecl(TagDecl *decl) {
3475 for (auto I : decl->redecls()) {
3476 if (I->isCompleteDefinition() || I->isBeingDefined())
3477 return I;
3478 }
3479 // If there's no definition (not even in progress), return what we have.
3480 return decl;
3481 }
3482
getDecl() const3483 TagDecl *TagType::getDecl() const {
3484 return getInterestingTagDecl(decl);
3485 }
3486
isBeingDefined() const3487 bool TagType::isBeingDefined() const {
3488 return getDecl()->isBeingDefined();
3489 }
3490
hasConstFields() const3491 bool RecordType::hasConstFields() const {
3492 std::vector<const RecordType*> RecordTypeList;
3493 RecordTypeList.push_back(this);
3494 unsigned NextToCheckIndex = 0;
3495
3496 while (RecordTypeList.size() > NextToCheckIndex) {
3497 for (FieldDecl *FD :
3498 RecordTypeList[NextToCheckIndex]->getDecl()->fields()) {
3499 QualType FieldTy = FD->getType();
3500 if (FieldTy.isConstQualified())
3501 return true;
3502 FieldTy = FieldTy.getCanonicalType();
3503 if (const auto *FieldRecTy = FieldTy->getAs<RecordType>()) {
3504 if (llvm::find(RecordTypeList, FieldRecTy) == RecordTypeList.end())
3505 RecordTypeList.push_back(FieldRecTy);
3506 }
3507 }
3508 ++NextToCheckIndex;
3509 }
3510 return false;
3511 }
3512
isQualifier() const3513 bool AttributedType::isQualifier() const {
3514 // FIXME: Generate this with TableGen.
3515 switch (getAttrKind()) {
3516 // These are type qualifiers in the traditional C sense: they annotate
3517 // something about a specific value/variable of a type. (They aren't
3518 // always part of the canonical type, though.)
3519 case attr::ObjCGC:
3520 case attr::ObjCOwnership:
3521 case attr::ObjCInertUnsafeUnretained:
3522 case attr::TypeNonNull:
3523 case attr::TypeNullable:
3524 case attr::TypeNullableResult:
3525 case attr::TypeNullUnspecified:
3526 case attr::LifetimeBound:
3527 case attr::AddressSpace:
3528 return true;
3529
3530 // All other type attributes aren't qualifiers; they rewrite the modified
3531 // type to be a semantically different type.
3532 default:
3533 return false;
3534 }
3535 }
3536
isMSTypeSpec() const3537 bool AttributedType::isMSTypeSpec() const {
3538 // FIXME: Generate this with TableGen?
3539 switch (getAttrKind()) {
3540 default: return false;
3541 case attr::Ptr32:
3542 case attr::Ptr64:
3543 case attr::SPtr:
3544 case attr::UPtr:
3545 return true;
3546 }
3547 llvm_unreachable("invalid attr kind");
3548 }
3549
isCallingConv() const3550 bool AttributedType::isCallingConv() const {
3551 // FIXME: Generate this with TableGen.
3552 switch (getAttrKind()) {
3553 default: return false;
3554 case attr::Pcs:
3555 case attr::CDecl:
3556 case attr::FastCall:
3557 case attr::StdCall:
3558 case attr::ThisCall:
3559 case attr::RegCall:
3560 case attr::SwiftCall:
3561 case attr::VectorCall:
3562 case attr::AArch64VectorPcs:
3563 case attr::Pascal:
3564 case attr::MSABI:
3565 case attr::SysVABI:
3566 case attr::IntelOclBicc:
3567 case attr::PreserveMost:
3568 case attr::PreserveAll:
3569 return true;
3570 }
3571 llvm_unreachable("invalid attr kind");
3572 }
3573
getDecl() const3574 CXXRecordDecl *InjectedClassNameType::getDecl() const {
3575 return cast<CXXRecordDecl>(getInterestingTagDecl(Decl));
3576 }
3577
getIdentifier() const3578 IdentifierInfo *TemplateTypeParmType::getIdentifier() const {
3579 return isCanonicalUnqualified() ? nullptr : getDecl()->getIdentifier();
3580 }
3581
SubstTemplateTypeParmPackType(const TemplateTypeParmType * Param,QualType Canon,const TemplateArgument & ArgPack)3582 SubstTemplateTypeParmPackType::SubstTemplateTypeParmPackType(
3583 const TemplateTypeParmType *Param, QualType Canon,
3584 const TemplateArgument &ArgPack)
3585 : Type(SubstTemplateTypeParmPack, Canon,
3586 TypeDependence::DependentInstantiation |
3587 TypeDependence::UnexpandedPack),
3588 Replaced(Param), Arguments(ArgPack.pack_begin()) {
3589 SubstTemplateTypeParmPackTypeBits.NumArgs = ArgPack.pack_size();
3590 }
3591
getArgumentPack() const3592 TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const {
3593 return TemplateArgument(llvm::makeArrayRef(Arguments, getNumArgs()));
3594 }
3595
Profile(llvm::FoldingSetNodeID & ID)3596 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
3597 Profile(ID, getReplacedParameter(), getArgumentPack());
3598 }
3599
Profile(llvm::FoldingSetNodeID & ID,const TemplateTypeParmType * Replaced,const TemplateArgument & ArgPack)3600 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
3601 const TemplateTypeParmType *Replaced,
3602 const TemplateArgument &ArgPack) {
3603 ID.AddPointer(Replaced);
3604 ID.AddInteger(ArgPack.pack_size());
3605 for (const auto &P : ArgPack.pack_elements())
3606 ID.AddPointer(P.getAsType().getAsOpaquePtr());
3607 }
3608
anyDependentTemplateArguments(const TemplateArgumentListInfo & Args,ArrayRef<TemplateArgument> Converted)3609 bool TemplateSpecializationType::anyDependentTemplateArguments(
3610 const TemplateArgumentListInfo &Args, ArrayRef<TemplateArgument> Converted) {
3611 return anyDependentTemplateArguments(Args.arguments(), Converted);
3612 }
3613
anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,ArrayRef<TemplateArgument> Converted)3614 bool TemplateSpecializationType::anyDependentTemplateArguments(
3615 ArrayRef<TemplateArgumentLoc> Args, ArrayRef<TemplateArgument> Converted) {
3616 for (const TemplateArgument &Arg : Converted)
3617 if (Arg.isDependent())
3618 return true;
3619 return false;
3620 }
3621
anyInstantiationDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args)3622 bool TemplateSpecializationType::anyInstantiationDependentTemplateArguments(
3623 ArrayRef<TemplateArgumentLoc> Args) {
3624 for (const TemplateArgumentLoc &ArgLoc : Args) {
3625 if (ArgLoc.getArgument().isInstantiationDependent())
3626 return true;
3627 }
3628 return false;
3629 }
3630
TemplateSpecializationType(TemplateName T,ArrayRef<TemplateArgument> Args,QualType Canon,QualType AliasedType)3631 TemplateSpecializationType::TemplateSpecializationType(
3632 TemplateName T, ArrayRef<TemplateArgument> Args, QualType Canon,
3633 QualType AliasedType)
3634 : Type(TemplateSpecialization, Canon.isNull() ? QualType(this, 0) : Canon,
3635 (Canon.isNull()
3636 ? TypeDependence::DependentInstantiation
3637 : Canon->getDependence() & ~(TypeDependence::VariablyModified |
3638 TypeDependence::UnexpandedPack)) |
3639 (toTypeDependence(T.getDependence()) &
3640 TypeDependence::UnexpandedPack)),
3641 Template(T) {
3642 TemplateSpecializationTypeBits.NumArgs = Args.size();
3643 TemplateSpecializationTypeBits.TypeAlias = !AliasedType.isNull();
3644
3645 assert(!T.getAsDependentTemplateName() &&
3646 "Use DependentTemplateSpecializationType for dependent template-name");
3647 assert((T.getKind() == TemplateName::Template ||
3648 T.getKind() == TemplateName::SubstTemplateTemplateParm ||
3649 T.getKind() == TemplateName::SubstTemplateTemplateParmPack) &&
3650 "Unexpected template name for TemplateSpecializationType");
3651
3652 auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1);
3653 for (const TemplateArgument &Arg : Args) {
3654 // Update instantiation-dependent, variably-modified, and error bits.
3655 // If the canonical type exists and is non-dependent, the template
3656 // specialization type can be non-dependent even if one of the type
3657 // arguments is. Given:
3658 // template<typename T> using U = int;
3659 // U<T> is always non-dependent, irrespective of the type T.
3660 // However, U<Ts> contains an unexpanded parameter pack, even though
3661 // its expansion (and thus its desugared type) doesn't.
3662 addDependence(toTypeDependence(Arg.getDependence()) &
3663 ~TypeDependence::Dependent);
3664 if (Arg.getKind() == TemplateArgument::Type)
3665 addDependence(Arg.getAsType()->getDependence() &
3666 TypeDependence::VariablyModified);
3667 new (TemplateArgs++) TemplateArgument(Arg);
3668 }
3669
3670 // Store the aliased type if this is a type alias template specialization.
3671 if (isTypeAlias()) {
3672 auto *Begin = reinterpret_cast<TemplateArgument *>(this + 1);
3673 *reinterpret_cast<QualType*>(Begin + getNumArgs()) = AliasedType;
3674 }
3675 }
3676
3677 void
Profile(llvm::FoldingSetNodeID & ID,TemplateName T,ArrayRef<TemplateArgument> Args,const ASTContext & Context)3678 TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
3679 TemplateName T,
3680 ArrayRef<TemplateArgument> Args,
3681 const ASTContext &Context) {
3682 T.Profile(ID);
3683 for (const TemplateArgument &Arg : Args)
3684 Arg.Profile(ID, Context);
3685 }
3686
3687 QualType
apply(const ASTContext & Context,QualType QT) const3688 QualifierCollector::apply(const ASTContext &Context, QualType QT) const {
3689 if (!hasNonFastQualifiers())
3690 return QT.withFastQualifiers(getFastQualifiers());
3691
3692 return Context.getQualifiedType(QT, *this);
3693 }
3694
3695 QualType
apply(const ASTContext & Context,const Type * T) const3696 QualifierCollector::apply(const ASTContext &Context, const Type *T) const {
3697 if (!hasNonFastQualifiers())
3698 return QualType(T, getFastQualifiers());
3699
3700 return Context.getQualifiedType(T, *this);
3701 }
3702
Profile(llvm::FoldingSetNodeID & ID,QualType BaseType,ArrayRef<QualType> typeArgs,ArrayRef<ObjCProtocolDecl * > protocols,bool isKindOf)3703 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID,
3704 QualType BaseType,
3705 ArrayRef<QualType> typeArgs,
3706 ArrayRef<ObjCProtocolDecl *> protocols,
3707 bool isKindOf) {
3708 ID.AddPointer(BaseType.getAsOpaquePtr());
3709 ID.AddInteger(typeArgs.size());
3710 for (auto typeArg : typeArgs)
3711 ID.AddPointer(typeArg.getAsOpaquePtr());
3712 ID.AddInteger(protocols.size());
3713 for (auto proto : protocols)
3714 ID.AddPointer(proto);
3715 ID.AddBoolean(isKindOf);
3716 }
3717
Profile(llvm::FoldingSetNodeID & ID)3718 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) {
3719 Profile(ID, getBaseType(), getTypeArgsAsWritten(),
3720 llvm::makeArrayRef(qual_begin(), getNumProtocols()),
3721 isKindOfTypeAsWritten());
3722 }
3723
Profile(llvm::FoldingSetNodeID & ID,const ObjCTypeParamDecl * OTPDecl,QualType CanonicalType,ArrayRef<ObjCProtocolDecl * > protocols)3724 void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID,
3725 const ObjCTypeParamDecl *OTPDecl,
3726 QualType CanonicalType,
3727 ArrayRef<ObjCProtocolDecl *> protocols) {
3728 ID.AddPointer(OTPDecl);
3729 ID.AddPointer(CanonicalType.getAsOpaquePtr());
3730 ID.AddInteger(protocols.size());
3731 for (auto proto : protocols)
3732 ID.AddPointer(proto);
3733 }
3734
Profile(llvm::FoldingSetNodeID & ID)3735 void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID) {
3736 Profile(ID, getDecl(), getCanonicalTypeInternal(),
3737 llvm::makeArrayRef(qual_begin(), getNumProtocols()));
3738 }
3739
3740 namespace {
3741
3742 /// The cached properties of a type.
3743 class CachedProperties {
3744 Linkage L;
3745 bool local;
3746
3747 public:
CachedProperties(Linkage L,bool local)3748 CachedProperties(Linkage L, bool local) : L(L), local(local) {}
3749
getLinkage() const3750 Linkage getLinkage() const { return L; }
hasLocalOrUnnamedType() const3751 bool hasLocalOrUnnamedType() const { return local; }
3752
merge(CachedProperties L,CachedProperties R)3753 friend CachedProperties merge(CachedProperties L, CachedProperties R) {
3754 Linkage MergedLinkage = minLinkage(L.L, R.L);
3755 return CachedProperties(MergedLinkage,
3756 L.hasLocalOrUnnamedType() | R.hasLocalOrUnnamedType());
3757 }
3758 };
3759
3760 } // namespace
3761
3762 static CachedProperties computeCachedProperties(const Type *T);
3763
3764 namespace clang {
3765
3766 /// The type-property cache. This is templated so as to be
3767 /// instantiated at an internal type to prevent unnecessary symbol
3768 /// leakage.
3769 template <class Private> class TypePropertyCache {
3770 public:
get(QualType T)3771 static CachedProperties get(QualType T) {
3772 return get(T.getTypePtr());
3773 }
3774
get(const Type * T)3775 static CachedProperties get(const Type *T) {
3776 ensure(T);
3777 return CachedProperties(T->TypeBits.getLinkage(),
3778 T->TypeBits.hasLocalOrUnnamedType());
3779 }
3780
ensure(const Type * T)3781 static void ensure(const Type *T) {
3782 // If the cache is valid, we're okay.
3783 if (T->TypeBits.isCacheValid()) return;
3784
3785 // If this type is non-canonical, ask its canonical type for the
3786 // relevant information.
3787 if (!T->isCanonicalUnqualified()) {
3788 const Type *CT = T->getCanonicalTypeInternal().getTypePtr();
3789 ensure(CT);
3790 T->TypeBits.CacheValid = true;
3791 T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage;
3792 T->TypeBits.CachedLocalOrUnnamed = CT->TypeBits.CachedLocalOrUnnamed;
3793 return;
3794 }
3795
3796 // Compute the cached properties and then set the cache.
3797 CachedProperties Result = computeCachedProperties(T);
3798 T->TypeBits.CacheValid = true;
3799 T->TypeBits.CachedLinkage = Result.getLinkage();
3800 T->TypeBits.CachedLocalOrUnnamed = Result.hasLocalOrUnnamedType();
3801 }
3802 };
3803
3804 } // namespace clang
3805
3806 // Instantiate the friend template at a private class. In a
3807 // reasonable implementation, these symbols will be internal.
3808 // It is terrible that this is the best way to accomplish this.
3809 namespace {
3810
3811 class Private {};
3812
3813 } // namespace
3814
3815 using Cache = TypePropertyCache<Private>;
3816
computeCachedProperties(const Type * T)3817 static CachedProperties computeCachedProperties(const Type *T) {
3818 switch (T->getTypeClass()) {
3819 #define TYPE(Class,Base)
3820 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
3821 #include "clang/AST/TypeNodes.inc"
3822 llvm_unreachable("didn't expect a non-canonical type here");
3823
3824 #define TYPE(Class,Base)
3825 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
3826 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
3827 #include "clang/AST/TypeNodes.inc"
3828 // Treat instantiation-dependent types as external.
3829 if (!T->isInstantiationDependentType()) T->dump();
3830 assert(T->isInstantiationDependentType());
3831 return CachedProperties(ExternalLinkage, false);
3832
3833 case Type::Auto:
3834 case Type::DeducedTemplateSpecialization:
3835 // Give non-deduced 'auto' types external linkage. We should only see them
3836 // here in error recovery.
3837 return CachedProperties(ExternalLinkage, false);
3838
3839 case Type::ExtInt:
3840 case Type::Builtin:
3841 // C++ [basic.link]p8:
3842 // A type is said to have linkage if and only if:
3843 // - it is a fundamental type (3.9.1); or
3844 return CachedProperties(ExternalLinkage, false);
3845
3846 case Type::Record:
3847 case Type::Enum: {
3848 const TagDecl *Tag = cast<TagType>(T)->getDecl();
3849
3850 // C++ [basic.link]p8:
3851 // - it is a class or enumeration type that is named (or has a name
3852 // for linkage purposes (7.1.3)) and the name has linkage; or
3853 // - it is a specialization of a class template (14); or
3854 Linkage L = Tag->getLinkageInternal();
3855 bool IsLocalOrUnnamed =
3856 Tag->getDeclContext()->isFunctionOrMethod() ||
3857 !Tag->hasNameForLinkage();
3858 return CachedProperties(L, IsLocalOrUnnamed);
3859 }
3860
3861 // C++ [basic.link]p8:
3862 // - it is a compound type (3.9.2) other than a class or enumeration,
3863 // compounded exclusively from types that have linkage; or
3864 case Type::Complex:
3865 return Cache::get(cast<ComplexType>(T)->getElementType());
3866 case Type::Pointer:
3867 return Cache::get(cast<PointerType>(T)->getPointeeType());
3868 case Type::BlockPointer:
3869 return Cache::get(cast<BlockPointerType>(T)->getPointeeType());
3870 case Type::LValueReference:
3871 case Type::RValueReference:
3872 return Cache::get(cast<ReferenceType>(T)->getPointeeType());
3873 case Type::MemberPointer: {
3874 const auto *MPT = cast<MemberPointerType>(T);
3875 return merge(Cache::get(MPT->getClass()),
3876 Cache::get(MPT->getPointeeType()));
3877 }
3878 case Type::ConstantArray:
3879 case Type::IncompleteArray:
3880 case Type::VariableArray:
3881 return Cache::get(cast<ArrayType>(T)->getElementType());
3882 case Type::Vector:
3883 case Type::ExtVector:
3884 return Cache::get(cast<VectorType>(T)->getElementType());
3885 case Type::ConstantMatrix:
3886 return Cache::get(cast<ConstantMatrixType>(T)->getElementType());
3887 case Type::FunctionNoProto:
3888 return Cache::get(cast<FunctionType>(T)->getReturnType());
3889 case Type::FunctionProto: {
3890 const auto *FPT = cast<FunctionProtoType>(T);
3891 CachedProperties result = Cache::get(FPT->getReturnType());
3892 for (const auto &ai : FPT->param_types())
3893 result = merge(result, Cache::get(ai));
3894 return result;
3895 }
3896 case Type::ObjCInterface: {
3897 Linkage L = cast<ObjCInterfaceType>(T)->getDecl()->getLinkageInternal();
3898 return CachedProperties(L, false);
3899 }
3900 case Type::ObjCObject:
3901 return Cache::get(cast<ObjCObjectType>(T)->getBaseType());
3902 case Type::ObjCObjectPointer:
3903 return Cache::get(cast<ObjCObjectPointerType>(T)->getPointeeType());
3904 case Type::Atomic:
3905 return Cache::get(cast<AtomicType>(T)->getValueType());
3906 case Type::Pipe:
3907 return Cache::get(cast<PipeType>(T)->getElementType());
3908 }
3909
3910 llvm_unreachable("unhandled type class");
3911 }
3912
3913 /// Determine the linkage of this type.
getLinkage() const3914 Linkage Type::getLinkage() const {
3915 Cache::ensure(this);
3916 return TypeBits.getLinkage();
3917 }
3918
hasUnnamedOrLocalType() const3919 bool Type::hasUnnamedOrLocalType() const {
3920 Cache::ensure(this);
3921 return TypeBits.hasLocalOrUnnamedType();
3922 }
3923
computeTypeLinkageInfo(const Type * T)3924 LinkageInfo LinkageComputer::computeTypeLinkageInfo(const Type *T) {
3925 switch (T->getTypeClass()) {
3926 #define TYPE(Class,Base)
3927 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
3928 #include "clang/AST/TypeNodes.inc"
3929 llvm_unreachable("didn't expect a non-canonical type here");
3930
3931 #define TYPE(Class,Base)
3932 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
3933 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
3934 #include "clang/AST/TypeNodes.inc"
3935 // Treat instantiation-dependent types as external.
3936 assert(T->isInstantiationDependentType());
3937 return LinkageInfo::external();
3938
3939 case Type::ExtInt:
3940 case Type::Builtin:
3941 return LinkageInfo::external();
3942
3943 case Type::Auto:
3944 case Type::DeducedTemplateSpecialization:
3945 return LinkageInfo::external();
3946
3947 case Type::Record:
3948 case Type::Enum:
3949 return getDeclLinkageAndVisibility(cast<TagType>(T)->getDecl());
3950
3951 case Type::Complex:
3952 return computeTypeLinkageInfo(cast<ComplexType>(T)->getElementType());
3953 case Type::Pointer:
3954 return computeTypeLinkageInfo(cast<PointerType>(T)->getPointeeType());
3955 case Type::BlockPointer:
3956 return computeTypeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType());
3957 case Type::LValueReference:
3958 case Type::RValueReference:
3959 return computeTypeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
3960 case Type::MemberPointer: {
3961 const auto *MPT = cast<MemberPointerType>(T);
3962 LinkageInfo LV = computeTypeLinkageInfo(MPT->getClass());
3963 LV.merge(computeTypeLinkageInfo(MPT->getPointeeType()));
3964 return LV;
3965 }
3966 case Type::ConstantArray:
3967 case Type::IncompleteArray:
3968 case Type::VariableArray:
3969 return computeTypeLinkageInfo(cast<ArrayType>(T)->getElementType());
3970 case Type::Vector:
3971 case Type::ExtVector:
3972 return computeTypeLinkageInfo(cast<VectorType>(T)->getElementType());
3973 case Type::ConstantMatrix:
3974 return computeTypeLinkageInfo(
3975 cast<ConstantMatrixType>(T)->getElementType());
3976 case Type::FunctionNoProto:
3977 return computeTypeLinkageInfo(cast<FunctionType>(T)->getReturnType());
3978 case Type::FunctionProto: {
3979 const auto *FPT = cast<FunctionProtoType>(T);
3980 LinkageInfo LV = computeTypeLinkageInfo(FPT->getReturnType());
3981 for (const auto &ai : FPT->param_types())
3982 LV.merge(computeTypeLinkageInfo(ai));
3983 return LV;
3984 }
3985 case Type::ObjCInterface:
3986 return getDeclLinkageAndVisibility(cast<ObjCInterfaceType>(T)->getDecl());
3987 case Type::ObjCObject:
3988 return computeTypeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
3989 case Type::ObjCObjectPointer:
3990 return computeTypeLinkageInfo(
3991 cast<ObjCObjectPointerType>(T)->getPointeeType());
3992 case Type::Atomic:
3993 return computeTypeLinkageInfo(cast<AtomicType>(T)->getValueType());
3994 case Type::Pipe:
3995 return computeTypeLinkageInfo(cast<PipeType>(T)->getElementType());
3996 }
3997
3998 llvm_unreachable("unhandled type class");
3999 }
4000
isLinkageValid() const4001 bool Type::isLinkageValid() const {
4002 if (!TypeBits.isCacheValid())
4003 return true;
4004
4005 Linkage L = LinkageComputer{}
4006 .computeTypeLinkageInfo(getCanonicalTypeInternal())
4007 .getLinkage();
4008 return L == TypeBits.getLinkage();
4009 }
4010
getTypeLinkageAndVisibility(const Type * T)4011 LinkageInfo LinkageComputer::getTypeLinkageAndVisibility(const Type *T) {
4012 if (!T->isCanonicalUnqualified())
4013 return computeTypeLinkageInfo(T->getCanonicalTypeInternal());
4014
4015 LinkageInfo LV = computeTypeLinkageInfo(T);
4016 assert(LV.getLinkage() == T->getLinkage());
4017 return LV;
4018 }
4019
getLinkageAndVisibility() const4020 LinkageInfo Type::getLinkageAndVisibility() const {
4021 return LinkageComputer{}.getTypeLinkageAndVisibility(this);
4022 }
4023
4024 Optional<NullabilityKind>
getNullability(const ASTContext & Context) const4025 Type::getNullability(const ASTContext &Context) const {
4026 QualType Type(this, 0);
4027 while (const auto *AT = Type->getAs<AttributedType>()) {
4028 // Check whether this is an attributed type with nullability
4029 // information.
4030 if (auto Nullability = AT->getImmediateNullability())
4031 return Nullability;
4032
4033 Type = AT->getEquivalentType();
4034 }
4035 return None;
4036 }
4037
canHaveNullability(bool ResultIfUnknown) const4038 bool Type::canHaveNullability(bool ResultIfUnknown) const {
4039 QualType type = getCanonicalTypeInternal();
4040
4041 switch (type->getTypeClass()) {
4042 // We'll only see canonical types here.
4043 #define NON_CANONICAL_TYPE(Class, Parent) \
4044 case Type::Class: \
4045 llvm_unreachable("non-canonical type");
4046 #define TYPE(Class, Parent)
4047 #include "clang/AST/TypeNodes.inc"
4048
4049 // Pointer types.
4050 case Type::Pointer:
4051 case Type::BlockPointer:
4052 case Type::MemberPointer:
4053 case Type::ObjCObjectPointer:
4054 return true;
4055
4056 // Dependent types that could instantiate to pointer types.
4057 case Type::UnresolvedUsing:
4058 case Type::TypeOfExpr:
4059 case Type::TypeOf:
4060 case Type::Decltype:
4061 case Type::UnaryTransform:
4062 case Type::TemplateTypeParm:
4063 case Type::SubstTemplateTypeParmPack:
4064 case Type::DependentName:
4065 case Type::DependentTemplateSpecialization:
4066 case Type::Auto:
4067 return ResultIfUnknown;
4068
4069 // Dependent template specializations can instantiate to pointer
4070 // types unless they're known to be specializations of a class
4071 // template.
4072 case Type::TemplateSpecialization:
4073 if (TemplateDecl *templateDecl
4074 = cast<TemplateSpecializationType>(type.getTypePtr())
4075 ->getTemplateName().getAsTemplateDecl()) {
4076 if (isa<ClassTemplateDecl>(templateDecl))
4077 return false;
4078 }
4079 return ResultIfUnknown;
4080
4081 case Type::Builtin:
4082 switch (cast<BuiltinType>(type.getTypePtr())->getKind()) {
4083 // Signed, unsigned, and floating-point types cannot have nullability.
4084 #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
4085 #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
4086 #define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
4087 #define BUILTIN_TYPE(Id, SingletonId)
4088 #include "clang/AST/BuiltinTypes.def"
4089 return false;
4090
4091 // Dependent types that could instantiate to a pointer type.
4092 case BuiltinType::Dependent:
4093 case BuiltinType::Overload:
4094 case BuiltinType::BoundMember:
4095 case BuiltinType::PseudoObject:
4096 case BuiltinType::UnknownAny:
4097 case BuiltinType::ARCUnbridgedCast:
4098 return ResultIfUnknown;
4099
4100 case BuiltinType::Void:
4101 case BuiltinType::ObjCId:
4102 case BuiltinType::ObjCClass:
4103 case BuiltinType::ObjCSel:
4104 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
4105 case BuiltinType::Id:
4106 #include "clang/Basic/OpenCLImageTypes.def"
4107 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
4108 case BuiltinType::Id:
4109 #include "clang/Basic/OpenCLExtensionTypes.def"
4110 case BuiltinType::OCLSampler:
4111 case BuiltinType::OCLEvent:
4112 case BuiltinType::OCLClkEvent:
4113 case BuiltinType::OCLQueue:
4114 case BuiltinType::OCLReserveID:
4115 #define SVE_TYPE(Name, Id, SingletonId) \
4116 case BuiltinType::Id:
4117 #include "clang/Basic/AArch64SVEACLETypes.def"
4118 #define PPC_VECTOR_TYPE(Name, Id, Size) \
4119 case BuiltinType::Id:
4120 #include "clang/Basic/PPCTypes.def"
4121 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
4122 #include "clang/Basic/RISCVVTypes.def"
4123 case BuiltinType::BuiltinFn:
4124 case BuiltinType::NullPtr:
4125 case BuiltinType::IncompleteMatrixIdx:
4126 case BuiltinType::OMPArraySection:
4127 case BuiltinType::OMPArrayShaping:
4128 case BuiltinType::OMPIterator:
4129 return false;
4130 }
4131 llvm_unreachable("unknown builtin type");
4132
4133 // Non-pointer types.
4134 case Type::Complex:
4135 case Type::LValueReference:
4136 case Type::RValueReference:
4137 case Type::ConstantArray:
4138 case Type::IncompleteArray:
4139 case Type::VariableArray:
4140 case Type::DependentSizedArray:
4141 case Type::DependentVector:
4142 case Type::DependentSizedExtVector:
4143 case Type::Vector:
4144 case Type::ExtVector:
4145 case Type::ConstantMatrix:
4146 case Type::DependentSizedMatrix:
4147 case Type::DependentAddressSpace:
4148 case Type::FunctionProto:
4149 case Type::FunctionNoProto:
4150 case Type::Record:
4151 case Type::DeducedTemplateSpecialization:
4152 case Type::Enum:
4153 case Type::InjectedClassName:
4154 case Type::PackExpansion:
4155 case Type::ObjCObject:
4156 case Type::ObjCInterface:
4157 case Type::Atomic:
4158 case Type::Pipe:
4159 case Type::ExtInt:
4160 case Type::DependentExtInt:
4161 return false;
4162 }
4163 llvm_unreachable("bad type kind!");
4164 }
4165
4166 llvm::Optional<NullabilityKind>
getImmediateNullability() const4167 AttributedType::getImmediateNullability() const {
4168 if (getAttrKind() == attr::TypeNonNull)
4169 return NullabilityKind::NonNull;
4170 if (getAttrKind() == attr::TypeNullable)
4171 return NullabilityKind::Nullable;
4172 if (getAttrKind() == attr::TypeNullUnspecified)
4173 return NullabilityKind::Unspecified;
4174 if (getAttrKind() == attr::TypeNullableResult)
4175 return NullabilityKind::NullableResult;
4176 return None;
4177 }
4178
stripOuterNullability(QualType & T)4179 Optional<NullabilityKind> AttributedType::stripOuterNullability(QualType &T) {
4180 QualType AttrTy = T;
4181 if (auto MacroTy = dyn_cast<MacroQualifiedType>(T))
4182 AttrTy = MacroTy->getUnderlyingType();
4183
4184 if (auto attributed = dyn_cast<AttributedType>(AttrTy)) {
4185 if (auto nullability = attributed->getImmediateNullability()) {
4186 T = attributed->getModifiedType();
4187 return nullability;
4188 }
4189 }
4190
4191 return None;
4192 }
4193
isBlockCompatibleObjCPointerType(ASTContext & ctx) const4194 bool Type::isBlockCompatibleObjCPointerType(ASTContext &ctx) const {
4195 const auto *objcPtr = getAs<ObjCObjectPointerType>();
4196 if (!objcPtr)
4197 return false;
4198
4199 if (objcPtr->isObjCIdType()) {
4200 // id is always okay.
4201 return true;
4202 }
4203
4204 // Blocks are NSObjects.
4205 if (ObjCInterfaceDecl *iface = objcPtr->getInterfaceDecl()) {
4206 if (iface->getIdentifier() != ctx.getNSObjectName())
4207 return false;
4208
4209 // Continue to check qualifiers, below.
4210 } else if (objcPtr->isObjCQualifiedIdType()) {
4211 // Continue to check qualifiers, below.
4212 } else {
4213 return false;
4214 }
4215
4216 // Check protocol qualifiers.
4217 for (ObjCProtocolDecl *proto : objcPtr->quals()) {
4218 // Blocks conform to NSObject and NSCopying.
4219 if (proto->getIdentifier() != ctx.getNSObjectName() &&
4220 proto->getIdentifier() != ctx.getNSCopyingName())
4221 return false;
4222 }
4223
4224 return true;
4225 }
4226
getObjCARCImplicitLifetime() const4227 Qualifiers::ObjCLifetime Type::getObjCARCImplicitLifetime() const {
4228 if (isObjCARCImplicitlyUnretainedType())
4229 return Qualifiers::OCL_ExplicitNone;
4230 return Qualifiers::OCL_Strong;
4231 }
4232
isObjCARCImplicitlyUnretainedType() const4233 bool Type::isObjCARCImplicitlyUnretainedType() const {
4234 assert(isObjCLifetimeType() &&
4235 "cannot query implicit lifetime for non-inferrable type");
4236
4237 const Type *canon = getCanonicalTypeInternal().getTypePtr();
4238
4239 // Walk down to the base type. We don't care about qualifiers for this.
4240 while (const auto *array = dyn_cast<ArrayType>(canon))
4241 canon = array->getElementType().getTypePtr();
4242
4243 if (const auto *opt = dyn_cast<ObjCObjectPointerType>(canon)) {
4244 // Class and Class<Protocol> don't require retention.
4245 if (opt->getObjectType()->isObjCClass())
4246 return true;
4247 }
4248
4249 return false;
4250 }
4251
isObjCNSObjectType() const4252 bool Type::isObjCNSObjectType() const {
4253 const Type *cur = this;
4254 while (true) {
4255 if (const auto *typedefType = dyn_cast<TypedefType>(cur))
4256 return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>();
4257
4258 // Single-step desugar until we run out of sugar.
4259 QualType next = cur->getLocallyUnqualifiedSingleStepDesugaredType();
4260 if (next.getTypePtr() == cur) return false;
4261 cur = next.getTypePtr();
4262 }
4263 }
4264
isObjCIndependentClassType() const4265 bool Type::isObjCIndependentClassType() const {
4266 if (const auto *typedefType = dyn_cast<TypedefType>(this))
4267 return typedefType->getDecl()->hasAttr<ObjCIndependentClassAttr>();
4268 return false;
4269 }
4270
isObjCRetainableType() const4271 bool Type::isObjCRetainableType() const {
4272 return isObjCObjectPointerType() ||
4273 isBlockPointerType() ||
4274 isObjCNSObjectType();
4275 }
4276
isObjCIndirectLifetimeType() const4277 bool Type::isObjCIndirectLifetimeType() const {
4278 if (isObjCLifetimeType())
4279 return true;
4280 if (const auto *OPT = getAs<PointerType>())
4281 return OPT->getPointeeType()->isObjCIndirectLifetimeType();
4282 if (const auto *Ref = getAs<ReferenceType>())
4283 return Ref->getPointeeType()->isObjCIndirectLifetimeType();
4284 if (const auto *MemPtr = getAs<MemberPointerType>())
4285 return MemPtr->getPointeeType()->isObjCIndirectLifetimeType();
4286 return false;
4287 }
4288
4289 /// Returns true if objects of this type have lifetime semantics under
4290 /// ARC.
isObjCLifetimeType() const4291 bool Type::isObjCLifetimeType() const {
4292 const Type *type = this;
4293 while (const ArrayType *array = type->getAsArrayTypeUnsafe())
4294 type = array->getElementType().getTypePtr();
4295 return type->isObjCRetainableType();
4296 }
4297
4298 /// Determine whether the given type T is a "bridgable" Objective-C type,
4299 /// which is either an Objective-C object pointer type or an
isObjCARCBridgableType() const4300 bool Type::isObjCARCBridgableType() const {
4301 return isObjCObjectPointerType() || isBlockPointerType();
4302 }
4303
4304 /// Determine whether the given type T is a "bridgeable" C type.
isCARCBridgableType() const4305 bool Type::isCARCBridgableType() const {
4306 const auto *Pointer = getAs<PointerType>();
4307 if (!Pointer)
4308 return false;
4309
4310 QualType Pointee = Pointer->getPointeeType();
4311 return Pointee->isVoidType() || Pointee->isRecordType();
4312 }
4313
4314 /// Check if the specified type is the CUDA device builtin surface type.
isCUDADeviceBuiltinSurfaceType() const4315 bool Type::isCUDADeviceBuiltinSurfaceType() const {
4316 if (const auto *RT = getAs<RecordType>())
4317 return RT->getDecl()->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>();
4318 return false;
4319 }
4320
4321 /// Check if the specified type is the CUDA device builtin texture type.
isCUDADeviceBuiltinTextureType() const4322 bool Type::isCUDADeviceBuiltinTextureType() const {
4323 if (const auto *RT = getAs<RecordType>())
4324 return RT->getDecl()->hasAttr<CUDADeviceBuiltinTextureTypeAttr>();
4325 return false;
4326 }
4327
hasSizedVLAType() const4328 bool Type::hasSizedVLAType() const {
4329 if (!isVariablyModifiedType()) return false;
4330
4331 if (const auto *ptr = getAs<PointerType>())
4332 return ptr->getPointeeType()->hasSizedVLAType();
4333 if (const auto *ref = getAs<ReferenceType>())
4334 return ref->getPointeeType()->hasSizedVLAType();
4335 if (const ArrayType *arr = getAsArrayTypeUnsafe()) {
4336 if (isa<VariableArrayType>(arr) &&
4337 cast<VariableArrayType>(arr)->getSizeExpr())
4338 return true;
4339
4340 return arr->getElementType()->hasSizedVLAType();
4341 }
4342
4343 return false;
4344 }
4345
isDestructedTypeImpl(QualType type)4346 QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) {
4347 switch (type.getObjCLifetime()) {
4348 case Qualifiers::OCL_None:
4349 case Qualifiers::OCL_ExplicitNone:
4350 case Qualifiers::OCL_Autoreleasing:
4351 break;
4352
4353 case Qualifiers::OCL_Strong:
4354 return DK_objc_strong_lifetime;
4355 case Qualifiers::OCL_Weak:
4356 return DK_objc_weak_lifetime;
4357 }
4358
4359 if (const auto *RT =
4360 type->getBaseElementTypeUnsafe()->getAs<RecordType>()) {
4361 const RecordDecl *RD = RT->getDecl();
4362 if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
4363 /// Check if this is a C++ object with a non-trivial destructor.
4364 if (CXXRD->hasDefinition() && !CXXRD->hasTrivialDestructor())
4365 return DK_cxx_destructor;
4366 } else {
4367 /// Check if this is a C struct that is non-trivial to destroy or an array
4368 /// that contains such a struct.
4369 if (RD->isNonTrivialToPrimitiveDestroy())
4370 return DK_nontrivial_c_struct;
4371 }
4372 }
4373
4374 return DK_none;
4375 }
4376
getMostRecentCXXRecordDecl() const4377 CXXRecordDecl *MemberPointerType::getMostRecentCXXRecordDecl() const {
4378 return getClass()->getAsCXXRecordDecl()->getMostRecentNonInjectedDecl();
4379 }
4380
FixedPointValueToString(SmallVectorImpl<char> & Str,llvm::APSInt Val,unsigned Scale)4381 void clang::FixedPointValueToString(SmallVectorImpl<char> &Str,
4382 llvm::APSInt Val, unsigned Scale) {
4383 llvm::FixedPointSemantics FXSema(Val.getBitWidth(), Scale, Val.isSigned(),
4384 /*IsSaturated=*/false,
4385 /*HasUnsignedPadding=*/false);
4386 llvm::APFixedPoint(Val, FXSema).toString(Str);
4387 }
4388
AutoType(QualType DeducedAsType,AutoTypeKeyword Keyword,TypeDependence ExtraDependence,ConceptDecl * TypeConstraintConcept,ArrayRef<TemplateArgument> TypeConstraintArgs)4389 AutoType::AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
4390 TypeDependence ExtraDependence,
4391 ConceptDecl *TypeConstraintConcept,
4392 ArrayRef<TemplateArgument> TypeConstraintArgs)
4393 : DeducedType(Auto, DeducedAsType, ExtraDependence) {
4394 AutoTypeBits.Keyword = (unsigned)Keyword;
4395 AutoTypeBits.NumArgs = TypeConstraintArgs.size();
4396 this->TypeConstraintConcept = TypeConstraintConcept;
4397 if (TypeConstraintConcept) {
4398 TemplateArgument *ArgBuffer = getArgBuffer();
4399 for (const TemplateArgument &Arg : TypeConstraintArgs) {
4400 addDependence(
4401 toSyntacticDependence(toTypeDependence(Arg.getDependence())));
4402
4403 new (ArgBuffer++) TemplateArgument(Arg);
4404 }
4405 }
4406 }
4407
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,QualType Deduced,AutoTypeKeyword Keyword,bool IsDependent,ConceptDecl * CD,ArrayRef<TemplateArgument> Arguments)4408 void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4409 QualType Deduced, AutoTypeKeyword Keyword,
4410 bool IsDependent, ConceptDecl *CD,
4411 ArrayRef<TemplateArgument> Arguments) {
4412 ID.AddPointer(Deduced.getAsOpaquePtr());
4413 ID.AddInteger((unsigned)Keyword);
4414 ID.AddBoolean(IsDependent);
4415 ID.AddPointer(CD);
4416 for (const TemplateArgument &Arg : Arguments)
4417 Arg.Profile(ID, Context);
4418 }
4419