Thanks to visit codestin.com
Credit goes to clang.llvm.org

clang 22.0.0git
Type.cpp
Go to the documentation of this file.
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"
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"
22#include "clang/AST/DeclObjC.h"
25#include "clang/AST/Expr.h"
34#include "clang/Basic/LLVM.h"
36#include "clang/Basic/Linkage.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/STLExtras.h"
46#include "llvm/ADT/SmallVector.h"
47#include "llvm/Support/ErrorHandling.h"
48#include "llvm/Support/MathExtras.h"
49#include <algorithm>
50#include <cassert>
51#include <cstdint>
52#include <cstring>
53#include <optional>
54
55using namespace clang;
56
58 return (*this != Other) &&
59 // CVR qualifiers superset
60 (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) &&
61 // ObjC GC qualifiers superset
62 ((getObjCGCAttr() == Other.getObjCGCAttr()) ||
63 (hasObjCGCAttr() && !Other.hasObjCGCAttr())) &&
64 // Address space superset.
65 ((getAddressSpace() == Other.getAddressSpace()) ||
66 (hasAddressSpace() && !Other.hasAddressSpace())) &&
67 // Lifetime qualifier superset.
68 ((getObjCLifetime() == Other.getObjCLifetime()) ||
69 (hasObjCLifetime() && !Other.hasObjCLifetime()));
70}
71
73 const ASTContext &Ctx) {
74 // In OpenCLC v2.0 s6.5.5: every address space except for __constant can be
75 // used as __generic.
76 return (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
77 // We also define global_device and global_host address spaces,
78 // to distinguish global pointers allocated on host from pointers
79 // allocated on device, which are a subset of __global.
82 (A == LangAS::sycl_global &&
84 // Consider pointer size address spaces to be equivalent to default.
87 // Default is a superset of SYCL address spaces.
88 (A == LangAS::Default &&
92 // In HIP device compilation, any cuda address space is allowed
93 // to implicitly cast into the default address space.
94 (A == LangAS::Default &&
96 B == LangAS::cuda_shared)) ||
97 // In HLSL, the this pointer for member functions points to the default
98 // address space. This causes a problem if the structure is in
99 // a different address space. We want to allow casting from these
100 // address spaces to default to work around this problem.
101 (A == LangAS::Default && B == LangAS::hlsl_private) ||
102 (A == LangAS::Default && B == LangAS::hlsl_device) ||
103 (A == LangAS::Default && B == LangAS::hlsl_input) ||
104 // Conversions from target specific address spaces may be legal
105 // depending on the target information.
107}
108
110 const Type *ty = getTypePtr();
111 NamedDecl *ND = nullptr;
112 if (const auto *DNT = ty->getAs<DependentNameType>())
113 return DNT->getIdentifier();
114 if (ty->isPointerOrReferenceType())
116 if (const auto *TT = ty->getAs<TagType>())
117 ND = TT->getOriginalDecl();
118 else if (ty->getTypeClass() == Type::Typedef)
119 ND = ty->castAs<TypedefType>()->getDecl();
120 else if (ty->isArrayType())
121 return ty->castAsArrayTypeUnsafe()
124
125 if (ND)
126 return ND->getIdentifier();
127 return nullptr;
128}
129
131 const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
132 return ClassDecl && ClassDecl->mayBeDynamicClass();
133}
134
136 const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
137 return !ClassDecl || ClassDecl->mayBeNonDynamicClass();
138}
139
140bool QualType::isConstant(QualType T, const ASTContext &Ctx) {
141 if (T.isConstQualified())
142 return true;
143
144 if (const ArrayType *AT = Ctx.getAsArrayType(T))
145 return AT->getElementType().isConstant(Ctx);
146
147 return T.getAddressSpace() == LangAS::opencl_constant;
148}
149
150std::optional<QualType::NonConstantStorageReason>
151QualType::isNonConstantStorage(const ASTContext &Ctx, bool ExcludeCtor,
152 bool ExcludeDtor) {
153 if (!isConstant(Ctx) && !(*this)->isReferenceType())
155 if (!Ctx.getLangOpts().CPlusPlus)
156 return std::nullopt;
157 if (const CXXRecordDecl *Record =
159 if (!ExcludeCtor)
161 if (Record->hasMutableFields())
163 if (!Record->hasTrivialDestructor() && !ExcludeDtor)
165 }
166 return std::nullopt;
167}
168
169// C++ [temp.dep.type]p1:
170// A type is dependent if it is...
171// - an array type constructed from any dependent type or whose
172// size is specified by a constant expression that is
173// value-dependent,
175 ArraySizeModifier sm, unsigned tq, const Expr *sz)
176 // Note, we need to check for DependentSizedArrayType explicitly here
177 // because we use a DependentSizedArrayType with no size expression as the
178 // type of a dependent array of unknown bound with a dependent braced
179 // initializer:
180 //
181 // template<int ...N> int arr[] = {N...};
182 : Type(tc, can,
183 et->getDependence() |
184 (sz ? toTypeDependence(
186 : TypeDependence::None) |
187 (tc == VariableArray ? TypeDependence::VariablyModified
188 : TypeDependence::None) |
189 (tc == DependentSizedArray
190 ? TypeDependence::DependentInstantiation
191 : TypeDependence::None)),
192 ElementType(et) {
193 ArrayTypeBits.IndexTypeQuals = tq;
194 ArrayTypeBits.SizeModifier = llvm::to_underlying(sm);
195}
196
198ConstantArrayType::Create(const ASTContext &Ctx, QualType ET, QualType Can,
199 const llvm::APInt &Sz, const Expr *SzExpr,
200 ArraySizeModifier SzMod, unsigned Qual) {
201 bool NeedsExternalSize = SzExpr != nullptr || Sz.ugt(0x0FFFFFFFFFFFFFFF) ||
202 Sz.getBitWidth() > 0xFF;
203 if (!NeedsExternalSize)
204 return new (Ctx, alignof(ConstantArrayType)) ConstantArrayType(
205 ET, Can, Sz.getBitWidth(), Sz.getZExtValue(), SzMod, Qual);
206
207 auto *SzPtr = new (Ctx, alignof(ConstantArrayType::ExternalSize))
208 ConstantArrayType::ExternalSize(Sz, SzExpr);
209 return new (Ctx, alignof(ConstantArrayType))
210 ConstantArrayType(ET, Can, SzPtr, SzMod, Qual);
211}
212
213unsigned
215 QualType ElementType,
216 const llvm::APInt &NumElements) {
217 uint64_t ElementSize = Context.getTypeSizeInChars(ElementType).getQuantity();
218
219 // Fast path the common cases so we can avoid the conservative computation
220 // below, which in common cases allocates "large" APSInt values, which are
221 // slow.
222
223 // If the element size is a power of 2, we can directly compute the additional
224 // number of addressing bits beyond those required for the element count.
225 if (llvm::isPowerOf2_64(ElementSize)) {
226 return NumElements.getActiveBits() + llvm::Log2_64(ElementSize);
227 }
228
229 // If both the element count and element size fit in 32-bits, we can do the
230 // computation directly in 64-bits.
231 if ((ElementSize >> 32) == 0 && NumElements.getBitWidth() <= 64 &&
232 (NumElements.getZExtValue() >> 32) == 0) {
233 uint64_t TotalSize = NumElements.getZExtValue() * ElementSize;
234 return llvm::bit_width(TotalSize);
235 }
236
237 // Otherwise, use APSInt to handle arbitrary sized values.
238 llvm::APSInt SizeExtended(NumElements, true);
239 unsigned SizeTypeBits = Context.getTypeSize(Context.getSizeType());
240 SizeExtended = SizeExtended.extend(
241 std::max(SizeTypeBits, SizeExtended.getBitWidth()) * 2);
242
243 llvm::APSInt TotalSize(llvm::APInt(SizeExtended.getBitWidth(), ElementSize));
244 TotalSize *= SizeExtended;
245
246 return TotalSize.getActiveBits();
247}
248
249unsigned
253
255 unsigned Bits = Context.getTypeSize(Context.getSizeType());
256
257 // Limit the number of bits in size_t so that maximal bit size fits 64 bit
258 // integer (see PR8256). We can do this as currently there is no hardware
259 // that supports full 64-bit virtual space.
260 if (Bits > 61)
261 Bits = 61;
262
263 return Bits;
264}
265
266void ConstantArrayType::Profile(llvm::FoldingSetNodeID &ID,
267 const ASTContext &Context, QualType ET,
268 uint64_t ArraySize, const Expr *SizeExpr,
269 ArraySizeModifier SizeMod, unsigned TypeQuals) {
270 ID.AddPointer(ET.getAsOpaquePtr());
271 ID.AddInteger(ArraySize);
272 ID.AddInteger(llvm::to_underlying(SizeMod));
273 ID.AddInteger(TypeQuals);
274 ID.AddBoolean(SizeExpr != nullptr);
275 if (SizeExpr)
276 SizeExpr->Profile(ID, Context, true);
277}
278
284
285DependentSizedArrayType::DependentSizedArrayType(QualType et, QualType can,
286 Expr *e, ArraySizeModifier sm,
287 unsigned tq)
288 : ArrayType(DependentSizedArray, et, can, sm, tq, e), SizeExpr((Stmt *)e) {}
289
290void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID,
291 const ASTContext &Context, QualType ET,
292 ArraySizeModifier SizeMod,
293 unsigned TypeQuals, Expr *E) {
294 ID.AddPointer(ET.getAsOpaquePtr());
295 ID.AddInteger(llvm::to_underlying(SizeMod));
296 ID.AddInteger(TypeQuals);
297 if (E)
298 E->Profile(ID, Context, true);
299}
300
301DependentVectorType::DependentVectorType(QualType ElementType,
302 QualType CanonType, Expr *SizeExpr,
303 SourceLocation Loc, VectorKind VecKind)
304 : Type(DependentVector, CanonType,
305 TypeDependence::DependentInstantiation |
306 ElementType->getDependence() |
307 (SizeExpr ? toTypeDependence(SizeExpr->getDependence())
308 : TypeDependence::None)),
309 ElementType(ElementType), SizeExpr(SizeExpr), Loc(Loc) {
310 VectorTypeBits.VecKind = llvm::to_underlying(VecKind);
311}
312
313void DependentVectorType::Profile(llvm::FoldingSetNodeID &ID,
314 const ASTContext &Context,
315 QualType ElementType, const Expr *SizeExpr,
316 VectorKind VecKind) {
317 ID.AddPointer(ElementType.getAsOpaquePtr());
318 ID.AddInteger(llvm::to_underlying(VecKind));
319 SizeExpr->Profile(ID, Context, true);
320}
321
322DependentSizedExtVectorType::DependentSizedExtVectorType(QualType ElementType,
323 QualType can,
324 Expr *SizeExpr,
325 SourceLocation loc)
326 : Type(DependentSizedExtVector, can,
327 TypeDependence::DependentInstantiation |
328 ElementType->getDependence() |
329 (SizeExpr ? toTypeDependence(SizeExpr->getDependence())
330 : TypeDependence::None)),
331 SizeExpr(SizeExpr), ElementType(ElementType), loc(loc) {}
332
333void DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID,
334 const ASTContext &Context,
335 QualType ElementType,
336 Expr *SizeExpr) {
337 ID.AddPointer(ElementType.getAsOpaquePtr());
338 SizeExpr->Profile(ID, Context, true);
339}
340
341DependentAddressSpaceType::DependentAddressSpaceType(QualType PointeeType,
342 QualType can,
343 Expr *AddrSpaceExpr,
344 SourceLocation loc)
345 : Type(DependentAddressSpace, can,
346 TypeDependence::DependentInstantiation |
347 PointeeType->getDependence() |
348 (AddrSpaceExpr ? toTypeDependence(AddrSpaceExpr->getDependence())
349 : TypeDependence::None)),
350 AddrSpaceExpr(AddrSpaceExpr), PointeeType(PointeeType), loc(loc) {}
351
352void DependentAddressSpaceType::Profile(llvm::FoldingSetNodeID &ID,
353 const ASTContext &Context,
354 QualType PointeeType,
355 Expr *AddrSpaceExpr) {
356 ID.AddPointer(PointeeType.getAsOpaquePtr());
357 AddrSpaceExpr->Profile(ID, Context, true);
358}
359
361 const Expr *RowExpr, const Expr *ColumnExpr)
362 : Type(tc, canonType,
363 (RowExpr ? (matrixType->getDependence() | TypeDependence::Dependent |
364 TypeDependence::Instantiation |
365 (matrixType->isVariablyModifiedType()
366 ? TypeDependence::VariablyModified
367 : TypeDependence::None) |
368 (matrixType->containsUnexpandedParameterPack() ||
369 (RowExpr &&
371 (ColumnExpr &&
373 ? TypeDependence::UnexpandedPack
375 : matrixType->getDependence())),
376 ElementType(matrixType) {}
377
379 unsigned nColumns, QualType canonType)
380 : ConstantMatrixType(ConstantMatrix, matrixType, nRows, nColumns,
381 canonType) {}
382
384 unsigned nRows, unsigned nColumns,
385 QualType canonType)
386 : MatrixType(tc, matrixType, canonType), NumRows(nRows),
387 NumColumns(nColumns) {}
388
389DependentSizedMatrixType::DependentSizedMatrixType(QualType ElementType,
390 QualType CanonicalType,
391 Expr *RowExpr,
392 Expr *ColumnExpr,
393 SourceLocation loc)
394 : MatrixType(DependentSizedMatrix, ElementType, CanonicalType, RowExpr,
395 ColumnExpr),
396 RowExpr(RowExpr), ColumnExpr(ColumnExpr), loc(loc) {}
397
398void DependentSizedMatrixType::Profile(llvm::FoldingSetNodeID &ID,
399 const ASTContext &CTX,
400 QualType ElementType, Expr *RowExpr,
401 Expr *ColumnExpr) {
402 ID.AddPointer(ElementType.getAsOpaquePtr());
403 RowExpr->Profile(ID, CTX, true);
404 ColumnExpr->Profile(ID, CTX, true);
405}
406
407VectorType::VectorType(QualType vecType, unsigned nElements, QualType canonType,
408 VectorKind vecKind)
409 : VectorType(Vector, vecType, nElements, canonType, vecKind) {}
410
411VectorType::VectorType(TypeClass tc, QualType vecType, unsigned nElements,
412 QualType canonType, VectorKind vecKind)
413 : Type(tc, canonType, vecType->getDependence()), ElementType(vecType) {
414 VectorTypeBits.VecKind = llvm::to_underlying(vecKind);
415 VectorTypeBits.NumElements = nElements;
416}
417
419 if (ctx.getLangOpts().HLSL)
420 return false;
421 return isExtVectorBoolType();
422}
423
424BitIntType::BitIntType(bool IsUnsigned, unsigned NumBits)
425 : Type(BitInt, QualType{}, TypeDependence::None), IsUnsigned(IsUnsigned),
426 NumBits(NumBits) {}
427
428DependentBitIntType::DependentBitIntType(bool IsUnsigned, Expr *NumBitsExpr)
429 : Type(DependentBitInt, QualType{},
430 toTypeDependence(NumBitsExpr->getDependence())),
431 ExprAndUnsigned(NumBitsExpr, IsUnsigned) {}
432
434 return ExprAndUnsigned.getInt();
435}
436
438 return ExprAndUnsigned.getPointer();
439}
440
441void DependentBitIntType::Profile(llvm::FoldingSetNodeID &ID,
442 const ASTContext &Context, bool IsUnsigned,
443 Expr *NumBitsExpr) {
444 ID.AddBoolean(IsUnsigned);
445 NumBitsExpr->Profile(ID, Context, true);
446}
447
449 return llvm::any_of(dependent_decls(),
450 [](const TypeCoupledDeclRefInfo &Info) {
451 return isa<FieldDecl>(Info.getDecl());
452 });
453}
454
455void CountAttributedType::Profile(llvm::FoldingSetNodeID &ID,
456 QualType WrappedTy, Expr *CountExpr,
457 bool CountInBytes, bool OrNull) {
458 ID.AddPointer(WrappedTy.getAsOpaquePtr());
459 ID.AddBoolean(CountInBytes);
460 ID.AddBoolean(OrNull);
461 // We profile it as a pointer as the StmtProfiler considers parameter
462 // expressions on function declaration and function definition as the
463 // same, resulting in count expression being evaluated with ParamDecl
464 // not in the function scope.
465 ID.AddPointer(CountExpr);
466}
467
468/// getArrayElementTypeNoTypeQual - If this is an array type, return the
469/// element type of the array, potentially with type qualifiers missing.
470/// This method should never be used when type qualifiers are meaningful.
472 // If this is directly an array type, return it.
473 if (const auto *ATy = dyn_cast<ArrayType>(this))
474 return ATy->getElementType().getTypePtr();
475
476 // If the canonical form of this type isn't the right kind, reject it.
477 if (!isa<ArrayType>(CanonicalType))
478 return nullptr;
479
480 // If this is a typedef for an array type, strip the typedef off without
481 // losing all typedef information.
483 ->getElementType()
484 .getTypePtr();
485}
486
487/// getDesugaredType - Return the specified type with any "sugar" removed from
488/// the type. This takes off typedefs, typeof's etc. If the outer level of
489/// the type is already concrete, it returns it unmodified. This is similar
490/// to getting the canonical type, but it doesn't remove *all* typedefs. For
491/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
492/// concrete.
495 return Context.getQualifiedType(split.Ty, split.Quals);
496}
497
498QualType QualType::getSingleStepDesugaredTypeImpl(QualType type,
499 const ASTContext &Context) {
500 SplitQualType split = type.split();
502 return Context.getQualifiedType(desugar, split.Quals);
503}
504
505// Check that no type class is polymorphic. LLVM style RTTI should be used
506// instead. If absolutely needed an exception can still be added here by
507// defining the appropriate macro (but please don't do this).
508#define TYPE(CLASS, BASE) \
509 static_assert(!std::is_polymorphic<CLASS##Type>::value, \
510 #CLASS "Type should not be polymorphic!");
511#include "clang/AST/TypeNodes.inc"
512
513// Check that no type class has a non-trival destructor. Types are
514// allocated with the BumpPtrAllocator from ASTContext and therefore
515// their destructor is not executed.
516#define TYPE(CLASS, BASE) \
517 static_assert(std::is_trivially_destructible<CLASS##Type>::value, \
518 #CLASS "Type should be trivially destructible!");
519#include "clang/AST/TypeNodes.inc"
520
522 switch (getTypeClass()) {
523#define ABSTRACT_TYPE(Class, Parent)
524#define TYPE(Class, Parent) \
525 case Type::Class: { \
526 const auto *ty = cast<Class##Type>(this); \
527 if (!ty->isSugared()) \
528 return QualType(ty, 0); \
529 return ty->desugar(); \
530 }
531#include "clang/AST/TypeNodes.inc"
532 }
533 llvm_unreachable("bad type kind!");
534}
535
538
539 QualType Cur = T;
540 while (true) {
541 const Type *CurTy = Qs.strip(Cur);
542 switch (CurTy->getTypeClass()) {
543#define ABSTRACT_TYPE(Class, Parent)
544#define TYPE(Class, Parent) \
545 case Type::Class: { \
546 const auto *Ty = cast<Class##Type>(CurTy); \
547 if (!Ty->isSugared()) \
548 return SplitQualType(Ty, Qs); \
549 Cur = Ty->desugar(); \
550 break; \
551 }
552#include "clang/AST/TypeNodes.inc"
553 }
554 }
555}
556
557SplitQualType QualType::getSplitUnqualifiedTypeImpl(QualType type) {
558 SplitQualType split = type.split();
559
560 // All the qualifiers we've seen so far.
561 Qualifiers quals = split.Quals;
562
563 // The last type node we saw with any nodes inside it.
564 const Type *lastTypeWithQuals = split.Ty;
565
566 while (true) {
567 QualType next;
568
569 // Do a single-step desugar, aborting the loop if the type isn't
570 // sugared.
571 switch (split.Ty->getTypeClass()) {
572#define ABSTRACT_TYPE(Class, Parent)
573#define TYPE(Class, Parent) \
574 case Type::Class: { \
575 const auto *ty = cast<Class##Type>(split.Ty); \
576 if (!ty->isSugared()) \
577 goto done; \
578 next = ty->desugar(); \
579 break; \
580 }
581#include "clang/AST/TypeNodes.inc"
582 }
583
584 // Otherwise, split the underlying type. If that yields qualifiers,
585 // update the information.
586 split = next.split();
587 if (!split.Quals.empty()) {
588 lastTypeWithQuals = split.Ty;
589 quals.addConsistentQualifiers(split.Quals);
590 }
591 }
592
593done:
594 return SplitQualType(lastTypeWithQuals, quals);
595}
596
598 // FIXME: this seems inherently un-qualifiers-safe.
599 while (const auto *PT = T->getAs<ParenType>())
600 T = PT->getInnerType();
601 return T;
602}
603
604/// This will check for a T (which should be a Type which can act as
605/// sugar, such as a TypedefType) by removing any existing sugar until it
606/// reaches a T or a non-sugared type.
607template <typename T> static const T *getAsSugar(const Type *Cur) {
608 while (true) {
609 if (const auto *Sugar = dyn_cast<T>(Cur))
610 return Sugar;
611 switch (Cur->getTypeClass()) {
612#define ABSTRACT_TYPE(Class, Parent)
613#define TYPE(Class, Parent) \
614 case Type::Class: { \
615 const auto *Ty = cast<Class##Type>(Cur); \
616 if (!Ty->isSugared()) \
617 return 0; \
618 Cur = Ty->desugar().getTypePtr(); \
619 break; \
620 }
621#include "clang/AST/TypeNodes.inc"
622 }
623 }
624}
625
626template <> const TypedefType *Type::getAs() const {
627 return getAsSugar<TypedefType>(this);
628}
629
630template <> const UsingType *Type::getAs() const {
631 return getAsSugar<UsingType>(this);
632}
633
634template <> const TemplateSpecializationType *Type::getAs() const {
636}
637
638template <> const AttributedType *Type::getAs() const {
639 return getAsSugar<AttributedType>(this);
640}
641
642template <> const BoundsAttributedType *Type::getAs() const {
644}
645
646template <> const CountAttributedType *Type::getAs() const {
648}
649
650/// getUnqualifiedDesugaredType - Pull any qualifiers and syntactic
651/// sugar off the given type. This should produce an object of the
652/// same dynamic type as the canonical type.
654 const Type *Cur = this;
655
656 while (true) {
657 switch (Cur->getTypeClass()) {
658#define ABSTRACT_TYPE(Class, Parent)
659#define TYPE(Class, Parent) \
660 case Class: { \
661 const auto *Ty = cast<Class##Type>(Cur); \
662 if (!Ty->isSugared()) \
663 return Cur; \
664 Cur = Ty->desugar().getTypePtr(); \
665 break; \
666 }
667#include "clang/AST/TypeNodes.inc"
668 }
669 }
670}
671
672bool Type::isClassType() const {
673 if (const auto *RT = getAsCanonical<RecordType>())
674 return RT->getOriginalDecl()->isClass();
675 return false;
676}
677
679 if (const auto *RT = getAsCanonical<RecordType>())
680 return RT->getOriginalDecl()->isStruct();
681 return false;
682}
683
685 const auto *RT = getAsCanonical<RecordType>();
686 if (!RT)
687 return false;
688 const auto *Decl = RT->getOriginalDecl();
689 if (!Decl->isStruct())
690 return false;
691 return Decl->getDefinitionOrSelf()->hasFlexibleArrayMember();
692}
693
695 if (const auto *RD = getAsRecordDecl())
696 return RD->hasAttr<ObjCBoxableAttr>();
697 return false;
698}
699
701 if (const auto *RT = getAsCanonical<RecordType>())
702 return RT->getOriginalDecl()->isInterface();
703 return false;
704}
705
707 if (const auto *RT = getAsCanonical<RecordType>())
708 return RT->getOriginalDecl()->isStructureOrClass();
709 return false;
710}
711
713 if (const auto *PT = getAsCanonical<PointerType>())
714 return PT->getPointeeType()->isVoidType();
715 return false;
716}
717
718bool Type::isUnionType() const {
719 if (const auto *RT = getAsCanonical<RecordType>())
720 return RT->getOriginalDecl()->isUnion();
721 return false;
722}
723
725 if (const auto *CT = getAsCanonical<ComplexType>())
726 return CT->getElementType()->isFloatingType();
727 return false;
728}
729
731 // Check for GCC complex integer extension.
733}
734
736 if (const auto *ET = getAsCanonical<EnumType>())
737 return ET->getOriginalDecl()->isScoped();
738 return false;
739}
740
744
746 if (const auto *Complex = getAs<ComplexType>())
747 if (Complex->getElementType()->isIntegerType())
748 return Complex;
749 return nullptr;
750}
751
753 if (const auto *PT = getAs<PointerType>())
754 return PT->getPointeeType();
755 if (const auto *OPT = getAs<ObjCObjectPointerType>())
756 return OPT->getPointeeType();
757 if (const auto *BPT = getAs<BlockPointerType>())
758 return BPT->getPointeeType();
759 if (const auto *RT = getAs<ReferenceType>())
760 return RT->getPointeeType();
761 if (const auto *MPT = getAs<MemberPointerType>())
762 return MPT->getPointeeType();
763 if (const auto *DT = getAs<DecayedType>())
764 return DT->getPointeeType();
765 return {};
766}
767
768const RecordType *Type::getAsStructureType() const {
769 // If this is directly a structure type, return it.
770 if (const auto *RT = dyn_cast<RecordType>(this)) {
771 if (RT->getOriginalDecl()->isStruct())
772 return RT;
773 }
774
775 // If the canonical form of this type isn't the right kind, reject it.
776 if (const auto *RT = dyn_cast<RecordType>(CanonicalType)) {
777 if (!RT->getOriginalDecl()->isStruct())
778 return nullptr;
779
780 // If this is a typedef for a structure type, strip the typedef off without
781 // losing all typedef information.
783 }
784 return nullptr;
785}
786
787const RecordType *Type::getAsUnionType() const {
788 // If this is directly a union type, return it.
789 if (const auto *RT = dyn_cast<RecordType>(this)) {
790 if (RT->getOriginalDecl()->isUnion())
791 return RT;
792 }
793
794 // If the canonical form of this type isn't the right kind, reject it.
795 if (const auto *RT = dyn_cast<RecordType>(CanonicalType)) {
796 if (!RT->getOriginalDecl()->isUnion())
797 return nullptr;
798
799 // If this is a typedef for a union type, strip the typedef off without
800 // losing all typedef information.
802 }
803
804 return nullptr;
805}
806
808 const ObjCObjectType *&bound) const {
809 bound = nullptr;
810
811 const auto *OPT = getAs<ObjCObjectPointerType>();
812 if (!OPT)
813 return false;
814
815 // Easy case: id.
816 if (OPT->isObjCIdType())
817 return true;
818
819 // If it's not a __kindof type, reject it now.
820 if (!OPT->isKindOfType())
821 return false;
822
823 // If it's Class or qualified Class, it's not an object type.
824 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType())
825 return false;
826
827 // Figure out the type bound for the __kindof type.
828 bound = OPT->getObjectType()
829 ->stripObjCKindOfTypeAndQuals(ctx)
830 ->getAs<ObjCObjectType>();
831 return true;
832}
833
835 const auto *OPT = getAs<ObjCObjectPointerType>();
836 if (!OPT)
837 return false;
838
839 // Easy case: Class.
840 if (OPT->isObjCClassType())
841 return true;
842
843 // If it's not a __kindof type, reject it now.
844 if (!OPT->isKindOfType())
845 return false;
846
847 // If it's Class or qualified Class, it's a class __kindof type.
848 return OPT->isObjCClassType() || OPT->isObjCQualifiedClassType();
849}
850
851ObjCTypeParamType::ObjCTypeParamType(const ObjCTypeParamDecl *D, QualType can,
853 : Type(ObjCTypeParam, can, toSemanticDependence(can->getDependence())),
854 OTPDecl(const_cast<ObjCTypeParamDecl *>(D)) {
855 initialize(protocols);
856}
857
858ObjCObjectType::ObjCObjectType(QualType Canonical, QualType Base,
859 ArrayRef<QualType> typeArgs,
861 bool isKindOf)
862 : Type(ObjCObject, Canonical, Base->getDependence()), BaseType(Base) {
863 ObjCObjectTypeBits.IsKindOf = isKindOf;
864
865 ObjCObjectTypeBits.NumTypeArgs = typeArgs.size();
866 assert(getTypeArgsAsWritten().size() == typeArgs.size() &&
867 "bitfield overflow in type argument count");
868 if (!typeArgs.empty())
869 memcpy(getTypeArgStorage(), typeArgs.data(),
870 typeArgs.size() * sizeof(QualType));
871
872 for (auto typeArg : typeArgs) {
873 addDependence(typeArg->getDependence() & ~TypeDependence::VariablyModified);
874 }
875 // Initialize the protocol qualifiers. The protocol storage is known
876 // after we set number of type arguments.
877 initialize(protocols);
878}
879
880bool ObjCObjectType::isSpecialized() const {
881 // If we have type arguments written here, the type is specialized.
882 if (ObjCObjectTypeBits.NumTypeArgs > 0)
883 return true;
884
885 // Otherwise, check whether the base type is specialized.
886 if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
887 // Terminate when we reach an interface type.
888 if (isa<ObjCInterfaceType>(objcObject))
889 return false;
890
891 return objcObject->isSpecialized();
892 }
893
894 // Not specialized.
895 return false;
896}
897
898ArrayRef<QualType> ObjCObjectType::getTypeArgs() const {
899 // We have type arguments written on this type.
900 if (isSpecializedAsWritten())
901 return getTypeArgsAsWritten();
902
903 // Look at the base type, which might have type arguments.
904 if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
905 // Terminate when we reach an interface type.
906 if (isa<ObjCInterfaceType>(objcObject))
907 return {};
908
909 return objcObject->getTypeArgs();
910 }
911
912 // No type arguments.
913 return {};
914}
915
916bool ObjCObjectType::isKindOfType() const {
917 if (isKindOfTypeAsWritten())
918 return true;
919
920 // Look at the base type, which might have type arguments.
921 if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
922 // Terminate when we reach an interface type.
923 if (isa<ObjCInterfaceType>(objcObject))
924 return false;
925
926 return objcObject->isKindOfType();
927 }
928
929 // Not a "__kindof" type.
930 return false;
931}
932
934ObjCObjectType::stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const {
935 if (!isKindOfType() && qual_empty())
936 return QualType(this, 0);
937
938 // Recursively strip __kindof.
939 SplitQualType splitBaseType = getBaseType().split();
940 QualType baseType(splitBaseType.Ty, 0);
941 if (const auto *baseObj = splitBaseType.Ty->getAs<ObjCObjectType>())
942 baseType = baseObj->stripObjCKindOfTypeAndQuals(ctx);
943
944 return ctx.getObjCObjectType(
945 ctx.getQualifiedType(baseType, splitBaseType.Quals),
946 getTypeArgsAsWritten(),
947 /*protocols=*/{},
948 /*isKindOf=*/false);
949}
950
952 ObjCInterfaceDecl *Canon = Decl->getCanonicalDecl();
953 if (ObjCInterfaceDecl *Def = Canon->getDefinition())
954 return Def;
955 return Canon;
956}
957
959 const ASTContext &ctx) const {
960 if (!isKindOfType() && qual_empty())
961 return this;
962
963 QualType obj = getObjectType()->stripObjCKindOfTypeAndQuals(ctx);
964 return ctx.getObjCObjectPointerType(obj)->castAs<ObjCObjectPointerType>();
965}
966
967namespace {
968
969/// Visitor used to perform a simple type transformation that does not change
970/// the semantics of the type.
971template <typename Derived>
972struct SimpleTransformVisitor : public TypeVisitor<Derived, QualType> {
973 ASTContext &Ctx;
974
975 QualType recurse(QualType type) {
976 // Split out the qualifiers from the type.
977 SplitQualType splitType = type.split();
978
979 // Visit the type itself.
980 QualType result = static_cast<Derived *>(this)->Visit(splitType.Ty);
981 if (result.isNull())
982 return result;
983
984 // Reconstruct the transformed type by applying the local qualifiers
985 // from the split type.
986 return Ctx.getQualifiedType(result, splitType.Quals);
987 }
988
989public:
990 explicit SimpleTransformVisitor(ASTContext &ctx) : Ctx(ctx) {}
991
992 // None of the clients of this transformation can occur where
993 // there are dependent types, so skip dependent types.
994#define TYPE(Class, Base)
995#define DEPENDENT_TYPE(Class, Base) \
996 QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
997#include "clang/AST/TypeNodes.inc"
998
999#define TRIVIAL_TYPE_CLASS(Class) \
1000 QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
1001#define SUGARED_TYPE_CLASS(Class) \
1002 QualType Visit##Class##Type(const Class##Type *T) { \
1003 if (!T->isSugared()) \
1004 return QualType(T, 0); \
1005 QualType desugaredType = recurse(T->desugar()); \
1006 if (desugaredType.isNull()) \
1007 return {}; \
1008 if (desugaredType.getAsOpaquePtr() == T->desugar().getAsOpaquePtr()) \
1009 return QualType(T, 0); \
1010 return desugaredType; \
1011 }
1012
1014
1015 QualType VisitComplexType(const ComplexType *T) {
1016 QualType elementType = recurse(T->getElementType());
1017 if (elementType.isNull())
1018 return {};
1019
1020 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
1021 return QualType(T, 0);
1022
1023 return Ctx.getComplexType(elementType);
1024 }
1025
1026 QualType VisitPointerType(const PointerType *T) {
1027 QualType pointeeType = recurse(T->getPointeeType());
1028 if (pointeeType.isNull())
1029 return {};
1030
1031 if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
1032 return QualType(T, 0);
1033
1034 return Ctx.getPointerType(pointeeType);
1035 }
1036
1037 QualType VisitBlockPointerType(const BlockPointerType *T) {
1038 QualType pointeeType = recurse(T->getPointeeType());
1039 if (pointeeType.isNull())
1040 return {};
1041
1042 if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
1043 return QualType(T, 0);
1044
1045 return Ctx.getBlockPointerType(pointeeType);
1046 }
1047
1048 QualType VisitLValueReferenceType(const LValueReferenceType *T) {
1049 QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
1050 if (pointeeType.isNull())
1051 return {};
1052
1053 if (pointeeType.getAsOpaquePtr() ==
1054 T->getPointeeTypeAsWritten().getAsOpaquePtr())
1055 return QualType(T, 0);
1056
1057 return Ctx.getLValueReferenceType(pointeeType, T->isSpelledAsLValue());
1058 }
1059
1060 QualType VisitRValueReferenceType(const RValueReferenceType *T) {
1061 QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
1062 if (pointeeType.isNull())
1063 return {};
1064
1065 if (pointeeType.getAsOpaquePtr() ==
1066 T->getPointeeTypeAsWritten().getAsOpaquePtr())
1067 return QualType(T, 0);
1068
1069 return Ctx.getRValueReferenceType(pointeeType);
1070 }
1071
1072 QualType VisitMemberPointerType(const MemberPointerType *T) {
1073 QualType pointeeType = recurse(T->getPointeeType());
1074 if (pointeeType.isNull())
1075 return {};
1076
1077 if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
1078 return QualType(T, 0);
1079
1080 return Ctx.getMemberPointerType(pointeeType, T->getQualifier(),
1081 T->getMostRecentCXXRecordDecl());
1082 }
1083
1084 QualType VisitConstantArrayType(const ConstantArrayType *T) {
1085 QualType elementType = recurse(T->getElementType());
1086 if (elementType.isNull())
1087 return {};
1088
1089 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
1090 return QualType(T, 0);
1091
1092 return Ctx.getConstantArrayType(elementType, T->getSize(), T->getSizeExpr(),
1093 T->getSizeModifier(),
1094 T->getIndexTypeCVRQualifiers());
1095 }
1096
1097 QualType VisitVariableArrayType(const VariableArrayType *T) {
1098 QualType elementType = recurse(T->getElementType());
1099 if (elementType.isNull())
1100 return {};
1101
1102 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
1103 return QualType(T, 0);
1104
1105 return Ctx.getVariableArrayType(elementType, T->getSizeExpr(),
1106 T->getSizeModifier(),
1107 T->getIndexTypeCVRQualifiers());
1108 }
1109
1110 QualType VisitIncompleteArrayType(const IncompleteArrayType *T) {
1111 QualType elementType = recurse(T->getElementType());
1112 if (elementType.isNull())
1113 return {};
1114
1115 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
1116 return QualType(T, 0);
1117
1118 return Ctx.getIncompleteArrayType(elementType, T->getSizeModifier(),
1119 T->getIndexTypeCVRQualifiers());
1120 }
1121
1122 QualType VisitVectorType(const VectorType *T) {
1123 QualType elementType = recurse(T->getElementType());
1124 if (elementType.isNull())
1125 return {};
1126
1127 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
1128 return QualType(T, 0);
1129
1130 return Ctx.getVectorType(elementType, T->getNumElements(),
1131 T->getVectorKind());
1132 }
1133
1134 QualType VisitExtVectorType(const ExtVectorType *T) {
1135 QualType elementType = recurse(T->getElementType());
1136 if (elementType.isNull())
1137 return {};
1138
1139 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
1140 return QualType(T, 0);
1141
1142 return Ctx.getExtVectorType(elementType, T->getNumElements());
1143 }
1144
1145 QualType VisitConstantMatrixType(const ConstantMatrixType *T) {
1146 QualType elementType = recurse(T->getElementType());
1147 if (elementType.isNull())
1148 return {};
1149 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
1150 return QualType(T, 0);
1151
1152 return Ctx.getConstantMatrixType(elementType, T->getNumRows(),
1153 T->getNumColumns());
1154 }
1155
1156 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1157 QualType returnType = recurse(T->getReturnType());
1158 if (returnType.isNull())
1159 return {};
1160
1161 if (returnType.getAsOpaquePtr() == T->getReturnType().getAsOpaquePtr())
1162 return QualType(T, 0);
1163
1164 return Ctx.getFunctionNoProtoType(returnType, T->getExtInfo());
1165 }
1166
1167 QualType VisitFunctionProtoType(const FunctionProtoType *T) {
1168 QualType returnType = recurse(T->getReturnType());
1169 if (returnType.isNull())
1170 return {};
1171
1172 // Transform parameter types.
1173 SmallVector<QualType, 4> paramTypes;
1174 bool paramChanged = false;
1175 for (auto paramType : T->getParamTypes()) {
1176 QualType newParamType = recurse(paramType);
1177 if (newParamType.isNull())
1178 return {};
1179
1180 if (newParamType.getAsOpaquePtr() != paramType.getAsOpaquePtr())
1181 paramChanged = true;
1182
1183 paramTypes.push_back(newParamType);
1184 }
1185
1186 // Transform extended info.
1187 FunctionProtoType::ExtProtoInfo info = T->getExtProtoInfo();
1188 bool exceptionChanged = false;
1189 if (info.ExceptionSpec.Type == EST_Dynamic) {
1190 SmallVector<QualType, 4> exceptionTypes;
1191 for (auto exceptionType : info.ExceptionSpec.Exceptions) {
1192 QualType newExceptionType = recurse(exceptionType);
1193 if (newExceptionType.isNull())
1194 return {};
1195
1196 if (newExceptionType.getAsOpaquePtr() != exceptionType.getAsOpaquePtr())
1197 exceptionChanged = true;
1198
1199 exceptionTypes.push_back(newExceptionType);
1200 }
1201
1202 if (exceptionChanged) {
1204 llvm::ArrayRef(exceptionTypes).copy(Ctx);
1205 }
1206 }
1207
1208 if (returnType.getAsOpaquePtr() == T->getReturnType().getAsOpaquePtr() &&
1209 !paramChanged && !exceptionChanged)
1210 return QualType(T, 0);
1211
1212 return Ctx.getFunctionType(returnType, paramTypes, info);
1213 }
1214
1215 QualType VisitParenType(const ParenType *T) {
1216 QualType innerType = recurse(T->getInnerType());
1217 if (innerType.isNull())
1218 return {};
1219
1220 if (innerType.getAsOpaquePtr() == T->getInnerType().getAsOpaquePtr())
1221 return QualType(T, 0);
1222
1223 return Ctx.getParenType(innerType);
1224 }
1225
1227 SUGARED_TYPE_CLASS(ObjCTypeParam)
1228 SUGARED_TYPE_CLASS(MacroQualified)
1229
1230 QualType VisitAdjustedType(const AdjustedType *T) {
1231 QualType originalType = recurse(T->getOriginalType());
1232 if (originalType.isNull())
1233 return {};
1234
1235 QualType adjustedType = recurse(T->getAdjustedType());
1236 if (adjustedType.isNull())
1237 return {};
1238
1239 if (originalType.getAsOpaquePtr() ==
1240 T->getOriginalType().getAsOpaquePtr() &&
1241 adjustedType.getAsOpaquePtr() == T->getAdjustedType().getAsOpaquePtr())
1242 return QualType(T, 0);
1243
1244 return Ctx.getAdjustedType(originalType, adjustedType);
1245 }
1246
1247 QualType VisitDecayedType(const DecayedType *T) {
1248 QualType originalType = recurse(T->getOriginalType());
1249 if (originalType.isNull())
1250 return {};
1251
1252 if (originalType.getAsOpaquePtr() == T->getOriginalType().getAsOpaquePtr())
1253 return QualType(T, 0);
1254
1255 return Ctx.getDecayedType(originalType);
1256 }
1257
1258 QualType VisitArrayParameterType(const ArrayParameterType *T) {
1259 QualType ArrTy = VisitConstantArrayType(T);
1260 if (ArrTy.isNull())
1261 return {};
1262
1263 return Ctx.getArrayParameterType(ArrTy);
1264 }
1265
1266 SUGARED_TYPE_CLASS(TypeOfExpr)
1267 SUGARED_TYPE_CLASS(TypeOf)
1268 SUGARED_TYPE_CLASS(Decltype)
1269 SUGARED_TYPE_CLASS(UnaryTransform)
1272
1273 QualType VisitAttributedType(const AttributedType *T) {
1274 QualType modifiedType = recurse(T->getModifiedType());
1275 if (modifiedType.isNull())
1276 return {};
1277
1278 QualType equivalentType = recurse(T->getEquivalentType());
1279 if (equivalentType.isNull())
1280 return {};
1281
1282 if (modifiedType.getAsOpaquePtr() ==
1283 T->getModifiedType().getAsOpaquePtr() &&
1284 equivalentType.getAsOpaquePtr() ==
1285 T->getEquivalentType().getAsOpaquePtr())
1286 return QualType(T, 0);
1287
1288 return Ctx.getAttributedType(T->getAttrKind(), modifiedType, equivalentType,
1289 T->getAttr());
1290 }
1291
1292 QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
1293 QualType replacementType = recurse(T->getReplacementType());
1294 if (replacementType.isNull())
1295 return {};
1296
1297 if (replacementType.getAsOpaquePtr() ==
1298 T->getReplacementType().getAsOpaquePtr())
1299 return QualType(T, 0);
1300
1302 replacementType, T->getAssociatedDecl(), T->getIndex(),
1303 T->getPackIndex(), T->getFinal());
1304 }
1305
1306 // FIXME: Non-trivial to implement, but important for C++
1307 SUGARED_TYPE_CLASS(TemplateSpecialization)
1308
1309 QualType VisitAutoType(const AutoType *T) {
1310 if (!T->isDeduced())
1311 return QualType(T, 0);
1312
1313 QualType deducedType = recurse(T->getDeducedType());
1314 if (deducedType.isNull())
1315 return {};
1316
1317 if (deducedType.getAsOpaquePtr() == T->getDeducedType().getAsOpaquePtr())
1318 return QualType(T, 0);
1319
1320 return Ctx.getAutoType(deducedType, T->getKeyword(), T->isDependentType(),
1321 /*IsPack=*/false, T->getTypeConstraintConcept(),
1322 T->getTypeConstraintArguments());
1323 }
1324
1325 QualType VisitObjCObjectType(const ObjCObjectType *T) {
1326 QualType baseType = recurse(T->getBaseType());
1327 if (baseType.isNull())
1328 return {};
1329
1330 // Transform type arguments.
1331 bool typeArgChanged = false;
1332 SmallVector<QualType, 4> typeArgs;
1333 for (auto typeArg : T->getTypeArgsAsWritten()) {
1334 QualType newTypeArg = recurse(typeArg);
1335 if (newTypeArg.isNull())
1336 return {};
1337
1338 if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr())
1339 typeArgChanged = true;
1340
1341 typeArgs.push_back(newTypeArg);
1342 }
1343
1344 if (baseType.getAsOpaquePtr() == T->getBaseType().getAsOpaquePtr() &&
1345 !typeArgChanged)
1346 return QualType(T, 0);
1347
1348 return Ctx.getObjCObjectType(
1349 baseType, typeArgs,
1350 llvm::ArrayRef(T->qual_begin(), T->getNumProtocols()),
1351 T->isKindOfTypeAsWritten());
1352 }
1353
1354 TRIVIAL_TYPE_CLASS(ObjCInterface)
1355
1356 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1357 QualType pointeeType = recurse(T->getPointeeType());
1358 if (pointeeType.isNull())
1359 return {};
1360
1361 if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
1362 return QualType(T, 0);
1363
1364 return Ctx.getObjCObjectPointerType(pointeeType);
1365 }
1366
1367 QualType VisitAtomicType(const AtomicType *T) {
1368 QualType valueType = recurse(T->getValueType());
1369 if (valueType.isNull())
1370 return {};
1371
1372 if (valueType.getAsOpaquePtr() == T->getValueType().getAsOpaquePtr())
1373 return QualType(T, 0);
1374
1375 return Ctx.getAtomicType(valueType);
1376 }
1377
1378#undef TRIVIAL_TYPE_CLASS
1379#undef SUGARED_TYPE_CLASS
1380};
1381
1382struct SubstObjCTypeArgsVisitor
1383 : public SimpleTransformVisitor<SubstObjCTypeArgsVisitor> {
1384 using BaseType = SimpleTransformVisitor<SubstObjCTypeArgsVisitor>;
1385
1386 ArrayRef<QualType> TypeArgs;
1387 ObjCSubstitutionContext SubstContext;
1388
1389 SubstObjCTypeArgsVisitor(ASTContext &ctx, ArrayRef<QualType> typeArgs,
1391 : BaseType(ctx), TypeArgs(typeArgs), SubstContext(context) {}
1392
1393 QualType VisitObjCTypeParamType(const ObjCTypeParamType *OTPTy) {
1394 // Replace an Objective-C type parameter reference with the corresponding
1395 // type argument.
1396 ObjCTypeParamDecl *typeParam = OTPTy->getDecl();
1397 // If we have type arguments, use them.
1398 if (!TypeArgs.empty()) {
1399 QualType argType = TypeArgs[typeParam->getIndex()];
1400 if (OTPTy->qual_empty())
1401 return argType;
1402
1403 // Apply protocol lists if exists.
1404 bool hasError;
1405 SmallVector<ObjCProtocolDecl *, 8> protocolsVec;
1406 protocolsVec.append(OTPTy->qual_begin(), OTPTy->qual_end());
1407 ArrayRef<ObjCProtocolDecl *> protocolsToApply = protocolsVec;
1408 return Ctx.applyObjCProtocolQualifiers(
1409 argType, protocolsToApply, hasError, true /*allowOnPointerType*/);
1410 }
1411
1412 switch (SubstContext) {
1413 case ObjCSubstitutionContext::Ordinary:
1414 case ObjCSubstitutionContext::Parameter:
1415 case ObjCSubstitutionContext::Superclass:
1416 // Substitute the bound.
1417 return typeParam->getUnderlyingType();
1418
1419 case ObjCSubstitutionContext::Result:
1420 case ObjCSubstitutionContext::Property: {
1421 // Substitute the __kindof form of the underlying type.
1422 const auto *objPtr =
1423 typeParam->getUnderlyingType()->castAs<ObjCObjectPointerType>();
1424
1425 // __kindof types, id, and Class don't need an additional
1426 // __kindof.
1427 if (objPtr->isKindOfType() || objPtr->isObjCIdOrClassType())
1428 return typeParam->getUnderlyingType();
1429
1430 // Add __kindof.
1431 const auto *obj = objPtr->getObjectType();
1432 QualType resultTy = Ctx.getObjCObjectType(
1433 obj->getBaseType(), obj->getTypeArgsAsWritten(), obj->getProtocols(),
1434 /*isKindOf=*/true);
1435
1436 // Rebuild object pointer type.
1437 return Ctx.getObjCObjectPointerType(resultTy);
1438 }
1439 }
1440 llvm_unreachable("Unexpected ObjCSubstitutionContext!");
1441 }
1442
1443 QualType VisitFunctionType(const FunctionType *funcType) {
1444 // If we have a function type, update the substitution context
1445 // appropriately.
1446
1447 // Substitute result type.
1448 QualType returnType = funcType->getReturnType().substObjCTypeArgs(
1449 Ctx, TypeArgs, ObjCSubstitutionContext::Result);
1450 if (returnType.isNull())
1451 return {};
1452
1453 // Handle non-prototyped functions, which only substitute into the result
1454 // type.
1455 if (isa<FunctionNoProtoType>(funcType)) {
1456 // If the return type was unchanged, do nothing.
1457 if (returnType.getAsOpaquePtr() ==
1458 funcType->getReturnType().getAsOpaquePtr())
1459 return BaseType::VisitFunctionType(funcType);
1460
1461 // Otherwise, build a new type.
1462 return Ctx.getFunctionNoProtoType(returnType, funcType->getExtInfo());
1463 }
1464
1465 const auto *funcProtoType = cast<FunctionProtoType>(funcType);
1466
1467 // Transform parameter types.
1468 SmallVector<QualType, 4> paramTypes;
1469 bool paramChanged = false;
1470 for (auto paramType : funcProtoType->getParamTypes()) {
1471 QualType newParamType = paramType.substObjCTypeArgs(
1472 Ctx, TypeArgs, ObjCSubstitutionContext::Parameter);
1473 if (newParamType.isNull())
1474 return {};
1475
1476 if (newParamType.getAsOpaquePtr() != paramType.getAsOpaquePtr())
1477 paramChanged = true;
1478
1479 paramTypes.push_back(newParamType);
1480 }
1481
1482 // Transform extended info.
1483 FunctionProtoType::ExtProtoInfo info = funcProtoType->getExtProtoInfo();
1484 bool exceptionChanged = false;
1485 if (info.ExceptionSpec.Type == EST_Dynamic) {
1486 SmallVector<QualType, 4> exceptionTypes;
1487 for (auto exceptionType : info.ExceptionSpec.Exceptions) {
1488 QualType newExceptionType = exceptionType.substObjCTypeArgs(
1489 Ctx, TypeArgs, ObjCSubstitutionContext::Ordinary);
1490 if (newExceptionType.isNull())
1491 return {};
1492
1493 if (newExceptionType.getAsOpaquePtr() != exceptionType.getAsOpaquePtr())
1494 exceptionChanged = true;
1495
1496 exceptionTypes.push_back(newExceptionType);
1497 }
1498
1499 if (exceptionChanged) {
1501 llvm::ArrayRef(exceptionTypes).copy(Ctx);
1502 }
1503 }
1504
1505 if (returnType.getAsOpaquePtr() ==
1506 funcProtoType->getReturnType().getAsOpaquePtr() &&
1507 !paramChanged && !exceptionChanged)
1508 return BaseType::VisitFunctionType(funcType);
1509
1510 return Ctx.getFunctionType(returnType, paramTypes, info);
1511 }
1512
1513 QualType VisitObjCObjectType(const ObjCObjectType *objcObjectType) {
1514 // Substitute into the type arguments of a specialized Objective-C object
1515 // type.
1516 if (objcObjectType->isSpecializedAsWritten()) {
1517 SmallVector<QualType, 4> newTypeArgs;
1518 bool anyChanged = false;
1519 for (auto typeArg : objcObjectType->getTypeArgsAsWritten()) {
1520 QualType newTypeArg = typeArg.substObjCTypeArgs(
1521 Ctx, TypeArgs, ObjCSubstitutionContext::Ordinary);
1522 if (newTypeArg.isNull())
1523 return {};
1524
1525 if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr()) {
1526 // If we're substituting based on an unspecialized context type,
1527 // produce an unspecialized type.
1528 ArrayRef<ObjCProtocolDecl *> protocols(
1529 objcObjectType->qual_begin(), objcObjectType->getNumProtocols());
1530 if (TypeArgs.empty() &&
1531 SubstContext != ObjCSubstitutionContext::Superclass) {
1532 return Ctx.getObjCObjectType(
1533 objcObjectType->getBaseType(), {}, protocols,
1534 objcObjectType->isKindOfTypeAsWritten());
1535 }
1536
1537 anyChanged = true;
1538 }
1539
1540 newTypeArgs.push_back(newTypeArg);
1541 }
1542
1543 if (anyChanged) {
1544 ArrayRef<ObjCProtocolDecl *> protocols(
1545 objcObjectType->qual_begin(), objcObjectType->getNumProtocols());
1546 return Ctx.getObjCObjectType(objcObjectType->getBaseType(), newTypeArgs,
1547 protocols,
1548 objcObjectType->isKindOfTypeAsWritten());
1549 }
1550 }
1551
1552 return BaseType::VisitObjCObjectType(objcObjectType);
1553 }
1554
1555 QualType VisitAttributedType(const AttributedType *attrType) {
1556 QualType newType = BaseType::VisitAttributedType(attrType);
1557 if (newType.isNull())
1558 return {};
1559
1560 const auto *newAttrType = dyn_cast<AttributedType>(newType.getTypePtr());
1561 if (!newAttrType || newAttrType->getAttrKind() != attr::ObjCKindOf)
1562 return newType;
1563
1564 // Find out if it's an Objective-C object or object pointer type;
1565 QualType newEquivType = newAttrType->getEquivalentType();
1566 const ObjCObjectPointerType *ptrType =
1567 newEquivType->getAs<ObjCObjectPointerType>();
1568 const ObjCObjectType *objType = ptrType
1569 ? ptrType->getObjectType()
1570 : newEquivType->getAs<ObjCObjectType>();
1571 if (!objType)
1572 return newType;
1573
1574 // Rebuild the "equivalent" type, which pushes __kindof down into
1575 // the object type.
1576 newEquivType = Ctx.getObjCObjectType(
1577 objType->getBaseType(), objType->getTypeArgsAsWritten(),
1578 objType->getProtocols(),
1579 // There is no need to apply kindof on an unqualified id type.
1580 /*isKindOf=*/objType->isObjCUnqualifiedId() ? false : true);
1581
1582 // If we started with an object pointer type, rebuild it.
1583 if (ptrType)
1584 newEquivType = Ctx.getObjCObjectPointerType(newEquivType);
1585
1586 // Rebuild the attributed type.
1587 return Ctx.getAttributedType(newAttrType->getAttrKind(),
1588 newAttrType->getModifiedType(), newEquivType,
1589 newAttrType->getAttr());
1590 }
1591};
1592
1593struct StripObjCKindOfTypeVisitor
1594 : public SimpleTransformVisitor<StripObjCKindOfTypeVisitor> {
1595 using BaseType = SimpleTransformVisitor<StripObjCKindOfTypeVisitor>;
1596
1597 explicit StripObjCKindOfTypeVisitor(ASTContext &ctx) : BaseType(ctx) {}
1598
1599 QualType VisitObjCObjectType(const ObjCObjectType *objType) {
1600 if (!objType->isKindOfType())
1601 return BaseType::VisitObjCObjectType(objType);
1602
1603 QualType baseType = objType->getBaseType().stripObjCKindOfType(Ctx);
1604 return Ctx.getObjCObjectType(baseType, objType->getTypeArgsAsWritten(),
1605 objType->getProtocols(),
1606 /*isKindOf=*/false);
1607 }
1608};
1609
1610} // namespace
1611
1613 const BuiltinType *BT = getTypePtr()->getAs<BuiltinType>();
1614 if (!BT) {
1615 const VectorType *VT = getTypePtr()->getAs<VectorType>();
1616 if (VT) {
1617 QualType ElementType = VT->getElementType();
1618 return ElementType.UseExcessPrecision(Ctx);
1619 }
1620 } else {
1621 switch (BT->getKind()) {
1622 case BuiltinType::Kind::Float16: {
1623 const TargetInfo &TI = Ctx.getTargetInfo();
1624 if (TI.hasFloat16Type() && !TI.hasFastHalfType() &&
1625 Ctx.getLangOpts().getFloat16ExcessPrecision() !=
1626 Ctx.getLangOpts().ExcessPrecisionKind::FPP_None)
1627 return true;
1628 break;
1629 }
1630 case BuiltinType::Kind::BFloat16: {
1631 const TargetInfo &TI = Ctx.getTargetInfo();
1632 if (TI.hasBFloat16Type() && !TI.hasFullBFloat16Type() &&
1633 Ctx.getLangOpts().getBFloat16ExcessPrecision() !=
1634 Ctx.getLangOpts().ExcessPrecisionKind::FPP_None)
1635 return true;
1636 break;
1637 }
1638 default:
1639 return false;
1640 }
1641 }
1642 return false;
1643}
1644
1645/// Substitute the given type arguments for Objective-C type
1646/// parameters within the given type, recursively.
1648 ArrayRef<QualType> typeArgs,
1649 ObjCSubstitutionContext context) const {
1650 SubstObjCTypeArgsVisitor visitor(ctx, typeArgs, context);
1651 return visitor.recurse(*this);
1652}
1653
1655 const DeclContext *dc,
1656 ObjCSubstitutionContext context) const {
1657 if (auto subs = objectType->getObjCSubstitutions(dc))
1658 return substObjCTypeArgs(dc->getParentASTContext(), *subs, context);
1659
1660 return *this;
1661}
1662
1664 // FIXME: Because ASTContext::getAttributedType() is non-const.
1665 auto &ctx = const_cast<ASTContext &>(constCtx);
1666 StripObjCKindOfTypeVisitor visitor(ctx);
1667 return visitor.recurse(*this);
1668}
1669
1671 QualType T = *this;
1672 if (const auto AT = T.getTypePtr()->getAs<AtomicType>())
1673 T = AT->getValueType();
1674 return T.getUnqualifiedType();
1675}
1676
1677std::optional<ArrayRef<QualType>>
1679 // Look through method scopes.
1680 if (const auto method = dyn_cast<ObjCMethodDecl>(dc))
1681 dc = method->getDeclContext();
1682
1683 // Find the class or category in which the type we're substituting
1684 // was declared.
1685 const auto *dcClassDecl = dyn_cast<ObjCInterfaceDecl>(dc);
1686 const ObjCCategoryDecl *dcCategoryDecl = nullptr;
1687 ObjCTypeParamList *dcTypeParams = nullptr;
1688 if (dcClassDecl) {
1689 // If the class does not have any type parameters, there's no
1690 // substitution to do.
1691 dcTypeParams = dcClassDecl->getTypeParamList();
1692 if (!dcTypeParams)
1693 return std::nullopt;
1694 } else {
1695 // If we are in neither a class nor a category, there's no
1696 // substitution to perform.
1697 dcCategoryDecl = dyn_cast<ObjCCategoryDecl>(dc);
1698 if (!dcCategoryDecl)
1699 return std::nullopt;
1700
1701 // If the category does not have any type parameters, there's no
1702 // substitution to do.
1703 dcTypeParams = dcCategoryDecl->getTypeParamList();
1704 if (!dcTypeParams)
1705 return std::nullopt;
1706
1707 dcClassDecl = dcCategoryDecl->getClassInterface();
1708 if (!dcClassDecl)
1709 return std::nullopt;
1710 }
1711 assert(dcTypeParams && "No substitutions to perform");
1712 assert(dcClassDecl && "No class context");
1713
1714 // Find the underlying object type.
1715 const ObjCObjectType *objectType;
1716 if (const auto *objectPointerType = getAs<ObjCObjectPointerType>()) {
1717 objectType = objectPointerType->getObjectType();
1718 } else if (getAs<BlockPointerType>()) {
1719 ASTContext &ctx = dc->getParentASTContext();
1720 objectType = ctx.getObjCObjectType(ctx.ObjCBuiltinIdTy, {}, {})
1722 } else {
1723 objectType = getAs<ObjCObjectType>();
1724 }
1725
1726 /// Extract the class from the receiver object type.
1727 ObjCInterfaceDecl *curClassDecl =
1728 objectType ? objectType->getInterface() : nullptr;
1729 if (!curClassDecl) {
1730 // If we don't have a context type (e.g., this is "id" or some
1731 // variant thereof), substitute the bounds.
1732 return llvm::ArrayRef<QualType>();
1733 }
1734
1735 // Follow the superclass chain until we've mapped the receiver type
1736 // to the same class as the context.
1737 while (curClassDecl != dcClassDecl) {
1738 // Map to the superclass type.
1739 QualType superType = objectType->getSuperClassType();
1740 if (superType.isNull()) {
1741 objectType = nullptr;
1742 break;
1743 }
1744
1745 objectType = superType->castAs<ObjCObjectType>();
1746 curClassDecl = objectType->getInterface();
1747 }
1748
1749 // If we don't have a receiver type, or the receiver type does not
1750 // have type arguments, substitute in the defaults.
1751 if (!objectType || objectType->isUnspecialized()) {
1752 return llvm::ArrayRef<QualType>();
1753 }
1754
1755 // The receiver type has the type arguments we want.
1756 return objectType->getTypeArgs();
1757}
1758
1760 if (auto *IfaceT = getAsObjCInterfaceType()) {
1761 if (auto *ID = IfaceT->getInterface()) {
1762 if (ID->getTypeParamList())
1763 return true;
1764 }
1765 }
1766
1767 return false;
1768}
1769
1770void ObjCObjectType::computeSuperClassTypeSlow() const {
1771 // Retrieve the class declaration for this type. If there isn't one
1772 // (e.g., this is some variant of "id" or "Class"), then there is no
1773 // superclass type.
1774 ObjCInterfaceDecl *classDecl = getInterface();
1775 if (!classDecl) {
1776 CachedSuperClassType.setInt(true);
1777 return;
1778 }
1779
1780 // Extract the superclass type.
1781 const ObjCObjectType *superClassObjTy = classDecl->getSuperClassType();
1782 if (!superClassObjTy) {
1783 CachedSuperClassType.setInt(true);
1784 return;
1785 }
1786
1787 ObjCInterfaceDecl *superClassDecl = superClassObjTy->getInterface();
1788 if (!superClassDecl) {
1789 CachedSuperClassType.setInt(true);
1790 return;
1791 }
1792
1793 // If the superclass doesn't have type parameters, then there is no
1794 // substitution to perform.
1795 QualType superClassType(superClassObjTy, 0);
1796 ObjCTypeParamList *superClassTypeParams = superClassDecl->getTypeParamList();
1797 if (!superClassTypeParams) {
1798 CachedSuperClassType.setPointerAndInt(
1799 superClassType->castAs<ObjCObjectType>(), true);
1800 return;
1801 }
1802
1803 // If the superclass reference is unspecialized, return it.
1804 if (superClassObjTy->isUnspecialized()) {
1805 CachedSuperClassType.setPointerAndInt(superClassObjTy, true);
1806 return;
1807 }
1808
1809 // If the subclass is not parameterized, there aren't any type
1810 // parameters in the superclass reference to substitute.
1811 ObjCTypeParamList *typeParams = classDecl->getTypeParamList();
1812 if (!typeParams) {
1813 CachedSuperClassType.setPointerAndInt(
1814 superClassType->castAs<ObjCObjectType>(), true);
1815 return;
1816 }
1817
1818 // If the subclass type isn't specialized, return the unspecialized
1819 // superclass.
1820 if (isUnspecialized()) {
1821 QualType unspecializedSuper =
1823 superClassObjTy->getInterface());
1824 CachedSuperClassType.setPointerAndInt(
1825 unspecializedSuper->castAs<ObjCObjectType>(), true);
1826 return;
1827 }
1828
1829 // Substitute the provided type arguments into the superclass type.
1830 ArrayRef<QualType> typeArgs = getTypeArgs();
1831 assert(typeArgs.size() == typeParams->size());
1832 CachedSuperClassType.setPointerAndInt(
1833 superClassType
1834 .substObjCTypeArgs(classDecl->getASTContext(), typeArgs,
1836 ->castAs<ObjCObjectType>(),
1837 true);
1838}
1839
1841 if (auto interfaceDecl = getObjectType()->getInterface()) {
1842 return interfaceDecl->getASTContext()
1843 .getObjCInterfaceType(interfaceDecl)
1844 ->castAs<ObjCInterfaceType>();
1845 }
1846
1847 return nullptr;
1848}
1849
1851 QualType superObjectType = getObjectType()->getSuperClassType();
1852 if (superObjectType.isNull())
1853 return superObjectType;
1854
1856 return ctx.getObjCObjectPointerType(superObjectType);
1857}
1858
1860 // There is no sugar for ObjCObjectType's, just return the canonical
1861 // type pointer if it is the right class. There is no typedef information to
1862 // return and these cannot be Address-space qualified.
1863 if (const auto *T = getAs<ObjCObjectType>())
1864 if (T->getNumProtocols() && T->getInterface())
1865 return T;
1866 return nullptr;
1867}
1868
1870 return getAsObjCQualifiedInterfaceType() != nullptr;
1871}
1872
1874 // There is no sugar for ObjCQualifiedIdType's, just return the canonical
1875 // type pointer if it is the right class.
1876 if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
1877 if (OPT->isObjCQualifiedIdType())
1878 return OPT;
1879 }
1880 return nullptr;
1881}
1882
1884 // There is no sugar for ObjCQualifiedClassType's, just return the canonical
1885 // type pointer if it is the right class.
1886 if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
1887 if (OPT->isObjCQualifiedClassType())
1888 return OPT;
1889 }
1890 return nullptr;
1891}
1892
1894 if (const auto *OT = getAs<ObjCObjectType>()) {
1895 if (OT->getInterface())
1896 return OT;
1897 }
1898 return nullptr;
1899}
1900
1902 if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
1903 if (OPT->getInterfaceType())
1904 return OPT;
1905 }
1906 return nullptr;
1907}
1908
1910 QualType PointeeType;
1911 if (const auto *PT = getAsCanonical<PointerType>())
1912 PointeeType = PT->getPointeeType();
1913 else if (const auto *RT = getAsCanonical<ReferenceType>())
1914 PointeeType = RT->getPointeeType();
1915 else
1916 return nullptr;
1917 return PointeeType->getAsCXXRecordDecl();
1918}
1919
1920const TemplateSpecializationType *
1922 const auto *TST = getAs<TemplateSpecializationType>();
1923 while (TST && TST->isTypeAlias())
1924 TST = TST->desugar()->getAs<TemplateSpecializationType>();
1925 return TST;
1926}
1927
1929 switch (getTypeClass()) {
1930 case Type::DependentName:
1931 return cast<DependentNameType>(this)->getQualifier();
1932 case Type::TemplateSpecialization:
1934 ->getTemplateName()
1935 .getQualifier();
1936 case Type::Enum:
1937 case Type::Record:
1938 case Type::InjectedClassName:
1939 return cast<TagType>(this)->getQualifier();
1940 case Type::Typedef:
1941 return cast<TypedefType>(this)->getQualifier();
1942 case Type::UnresolvedUsing:
1943 return cast<UnresolvedUsingType>(this)->getQualifier();
1944 case Type::Using:
1945 return cast<UsingType>(this)->getQualifier();
1946 default:
1947 return std::nullopt;
1948 }
1949}
1950
1952 const Type *Cur = this;
1953 while (const auto *AT = Cur->getAs<AttributedType>()) {
1954 if (AT->getAttrKind() == AK)
1955 return true;
1956 Cur = AT->getEquivalentType().getTypePtr();
1957 }
1958 return false;
1959}
1960
1961namespace {
1962
1963class GetContainedDeducedTypeVisitor
1964 : public TypeVisitor<GetContainedDeducedTypeVisitor, Type *> {
1965 bool Syntactic;
1966
1967public:
1968 GetContainedDeducedTypeVisitor(bool Syntactic = false)
1969 : Syntactic(Syntactic) {}
1970
1971 using TypeVisitor<GetContainedDeducedTypeVisitor, Type *>::Visit;
1972
1973 Type *Visit(QualType T) {
1974 if (T.isNull())
1975 return nullptr;
1976 return Visit(T.getTypePtr());
1977 }
1978
1979 // The deduced type itself.
1980 Type *VisitDeducedType(const DeducedType *AT) {
1981 return const_cast<DeducedType *>(AT);
1982 }
1983
1984 // Only these types can contain the desired 'auto' type.
1985 Type *VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
1986 return Visit(T->getReplacementType());
1987 }
1988
1989 Type *VisitPointerType(const PointerType *T) {
1990 return Visit(T->getPointeeType());
1991 }
1992
1993 Type *VisitBlockPointerType(const BlockPointerType *T) {
1994 return Visit(T->getPointeeType());
1995 }
1996
1997 Type *VisitReferenceType(const ReferenceType *T) {
1998 return Visit(T->getPointeeTypeAsWritten());
1999 }
2000
2001 Type *VisitMemberPointerType(const MemberPointerType *T) {
2002 return Visit(T->getPointeeType());
2003 }
2004
2005 Type *VisitArrayType(const ArrayType *T) {
2006 return Visit(T->getElementType());
2007 }
2008
2009 Type *VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) {
2010 return Visit(T->getElementType());
2011 }
2012
2013 Type *VisitVectorType(const VectorType *T) {
2014 return Visit(T->getElementType());
2015 }
2016
2017 Type *VisitDependentSizedMatrixType(const DependentSizedMatrixType *T) {
2018 return Visit(T->getElementType());
2019 }
2020
2021 Type *VisitConstantMatrixType(const ConstantMatrixType *T) {
2022 return Visit(T->getElementType());
2023 }
2024
2025 Type *VisitFunctionProtoType(const FunctionProtoType *T) {
2026 if (Syntactic && T->hasTrailingReturn())
2027 return const_cast<FunctionProtoType *>(T);
2028 return VisitFunctionType(T);
2029 }
2030
2031 Type *VisitFunctionType(const FunctionType *T) {
2032 return Visit(T->getReturnType());
2033 }
2034
2035 Type *VisitParenType(const ParenType *T) { return Visit(T->getInnerType()); }
2036
2037 Type *VisitAttributedType(const AttributedType *T) {
2038 return Visit(T->getModifiedType());
2039 }
2040
2041 Type *VisitMacroQualifiedType(const MacroQualifiedType *T) {
2042 return Visit(T->getUnderlyingType());
2043 }
2044
2045 Type *VisitAdjustedType(const AdjustedType *T) {
2046 return Visit(T->getOriginalType());
2047 }
2048
2049 Type *VisitPackExpansionType(const PackExpansionType *T) {
2050 return Visit(T->getPattern());
2051 }
2052};
2053
2054} // namespace
2055
2056DeducedType *Type::getContainedDeducedType() const {
2057 return cast_or_null<DeducedType>(
2058 GetContainedDeducedTypeVisitor().Visit(this));
2059}
2060
2062 return isa_and_nonnull<FunctionType>(
2063 GetContainedDeducedTypeVisitor(true).Visit(this));
2064}
2065
2067 if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
2068 return VT->getElementType()->isIntegerType();
2069 if (CanonicalType->isSveVLSBuiltinType()) {
2070 const auto *VT = cast<BuiltinType>(CanonicalType);
2071 return VT->getKind() == BuiltinType::SveBool ||
2072 (VT->getKind() >= BuiltinType::SveInt8 &&
2073 VT->getKind() <= BuiltinType::SveUint64);
2074 }
2075 if (CanonicalType->isRVVVLSBuiltinType()) {
2076 const auto *VT = cast<BuiltinType>(CanonicalType);
2077 return (VT->getKind() >= BuiltinType::RvvInt8mf8 &&
2078 VT->getKind() <= BuiltinType::RvvUint64m8);
2079 }
2080
2081 return isIntegerType();
2082}
2083
2084/// Determine whether this type is an integral type.
2085///
2086/// This routine determines whether the given type is an integral type per
2087/// C++ [basic.fundamental]p7. Although the C standard does not define the
2088/// term "integral type", it has a similar term "integer type", and in C++
2089/// the two terms are equivalent. However, C's "integer type" includes
2090/// enumeration types, while C++'s "integer type" does not. The \c ASTContext
2091/// parameter is used to determine whether we should be following the C or
2092/// C++ rules when determining whether this type is an integral/integer type.
2093///
2094/// For cases where C permits "an integer type" and C++ permits "an integral
2095/// type", use this routine.
2096///
2097/// For cases where C permits "an integer type" and C++ permits "an integral
2098/// or enumeration type", use \c isIntegralOrEnumerationType() instead.
2099///
2100/// \param Ctx The context in which this type occurs.
2101///
2102/// \returns true if the type is considered an integral type, false otherwise.
2103bool Type::isIntegralType(const ASTContext &Ctx) const {
2104 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2105 return BT->isInteger();
2106
2107 // Complete enum types are integral in C.
2108 if (!Ctx.getLangOpts().CPlusPlus)
2109 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
2110 return IsEnumDeclComplete(ET->getOriginalDecl());
2111
2112 return isBitIntType();
2113}
2114
2116 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2117 return BT->isInteger();
2118
2119 if (isBitIntType())
2120 return true;
2121
2123}
2124
2126 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
2127 return !ET->getOriginalDecl()->isScoped();
2128
2129 return false;
2130}
2131
2132bool Type::isCharType() const {
2133 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2134 return BT->getKind() == BuiltinType::Char_U ||
2135 BT->getKind() == BuiltinType::UChar ||
2136 BT->getKind() == BuiltinType::Char_S ||
2137 BT->getKind() == BuiltinType::SChar;
2138 return false;
2139}
2140
2142 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2143 return BT->getKind() == BuiltinType::WChar_S ||
2144 BT->getKind() == BuiltinType::WChar_U;
2145 return false;
2146}
2147
2148bool Type::isChar8Type() const {
2149 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
2150 return BT->getKind() == BuiltinType::Char8;
2151 return false;
2152}
2153
2155 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2156 return BT->getKind() == BuiltinType::Char16;
2157 return false;
2158}
2159
2161 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2162 return BT->getKind() == BuiltinType::Char32;
2163 return false;
2164}
2165
2166/// Determine whether this type is any of the built-in character
2167/// types.
2169 const auto *BT = dyn_cast<BuiltinType>(CanonicalType);
2170 if (!BT)
2171 return false;
2172 switch (BT->getKind()) {
2173 default:
2174 return false;
2175 case BuiltinType::Char_U:
2176 case BuiltinType::UChar:
2177 case BuiltinType::WChar_U:
2178 case BuiltinType::Char8:
2179 case BuiltinType::Char16:
2180 case BuiltinType::Char32:
2181 case BuiltinType::Char_S:
2182 case BuiltinType::SChar:
2183 case BuiltinType::WChar_S:
2184 return true;
2185 }
2186}
2187
2189 const auto *BT = dyn_cast<BuiltinType>(CanonicalType);
2190 if (!BT)
2191 return false;
2192 switch (BT->getKind()) {
2193 default:
2194 return false;
2195 case BuiltinType::Char8:
2196 case BuiltinType::Char16:
2197 case BuiltinType::Char32:
2198 return true;
2199 }
2200}
2201
2202/// isSignedIntegerType - Return true if this is an integer type that is
2203/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
2204/// an enum decl which has a signed representation
2206 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2207 return BT->isSignedInteger();
2208
2209 if (const auto *ED = getAsEnumDecl()) {
2210 // Incomplete enum types are not treated as integer types.
2211 // FIXME: In C++, enum types are never integer types.
2212 if (!ED->isComplete() || ED->isScoped())
2213 return false;
2214 return ED->getIntegerType()->isSignedIntegerType();
2215 }
2216
2217 if (const auto *IT = dyn_cast<BitIntType>(CanonicalType))
2218 return IT->isSigned();
2219 if (const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType))
2220 return IT->isSigned();
2221
2222 return false;
2223}
2224
2226 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2227 return BT->isSignedInteger();
2228
2229 if (const auto *ED = getAsEnumDecl()) {
2230 if (!ED->isComplete())
2231 return false;
2232 return ED->getIntegerType()->isSignedIntegerType();
2233 }
2234
2235 if (const auto *IT = dyn_cast<BitIntType>(CanonicalType))
2236 return IT->isSigned();
2237 if (const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType))
2238 return IT->isSigned();
2239
2240 return false;
2241}
2242
2244 if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
2245 return VT->getElementType()->isSignedIntegerOrEnumerationType();
2246 else
2248}
2249
2250/// isUnsignedIntegerType - Return true if this is an integer type that is
2251/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum
2252/// decl which has an unsigned representation
2254 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2255 return BT->isUnsignedInteger();
2256
2257 if (const auto *ED = getAsEnumDecl()) {
2258 // Incomplete enum types are not treated as integer types.
2259 // FIXME: In C++, enum types are never integer types.
2260 if (!ED->isComplete() || ED->isScoped())
2261 return false;
2262 return ED->getIntegerType()->isUnsignedIntegerType();
2263 }
2264
2265 if (const auto *IT = dyn_cast<BitIntType>(CanonicalType))
2266 return IT->isUnsigned();
2267 if (const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType))
2268 return IT->isUnsigned();
2269
2270 return false;
2271}
2272
2274 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2275 return BT->isUnsignedInteger();
2276
2277 if (const auto *ED = getAsEnumDecl()) {
2278 if (!ED->isComplete())
2279 return false;
2280 return ED->getIntegerType()->isUnsignedIntegerType();
2281 }
2282
2283 if (const auto *IT = dyn_cast<BitIntType>(CanonicalType))
2284 return IT->isUnsigned();
2285 if (const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType))
2286 return IT->isUnsigned();
2287
2288 return false;
2289}
2290
2292 if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
2293 return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
2294 if (const auto *VT = dyn_cast<MatrixType>(CanonicalType))
2295 return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
2296 if (CanonicalType->isSveVLSBuiltinType()) {
2297 const auto *VT = cast<BuiltinType>(CanonicalType);
2298 return VT->getKind() >= BuiltinType::SveUint8 &&
2299 VT->getKind() <= BuiltinType::SveUint64;
2300 }
2302}
2303
2305 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2306 return BT->isFloatingPoint();
2307 if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
2308 return CT->getElementType()->isFloatingType();
2309 return false;
2310}
2311
2313 if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
2314 return VT->getElementType()->isFloatingType();
2315 if (const auto *MT = dyn_cast<MatrixType>(CanonicalType))
2316 return MT->getElementType()->isFloatingType();
2317 return isFloatingType();
2318}
2319
2321 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2322 return BT->isFloatingPoint();
2323 return false;
2324}
2325
2326bool Type::isRealType() const {
2327 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2328 return BT->getKind() >= BuiltinType::Bool &&
2329 BT->getKind() <= BuiltinType::Ibm128;
2330 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
2331 const auto *ED = ET->getOriginalDecl();
2332 return !ED->isScoped() && ED->getDefinitionOrSelf()->isComplete();
2333 }
2334 return isBitIntType();
2335}
2336
2338 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2339 return BT->getKind() >= BuiltinType::Bool &&
2340 BT->getKind() <= BuiltinType::Ibm128;
2341 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
2342 // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
2343 // If a body isn't seen by the time we get here, return false.
2344 //
2345 // C++0x: Enumerations are not arithmetic types. For now, just return
2346 // false for scoped enumerations since that will disable any
2347 // unwanted implicit conversions.
2348 const auto *ED = ET->getOriginalDecl();
2349 return !ED->isScoped() && ED->getDefinitionOrSelf()->isComplete();
2350 }
2351 return isa<ComplexType>(CanonicalType) || isBitIntType();
2352}
2353
2355 if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
2356 return VT->getElementType()->isBooleanType();
2357 if (const auto *ED = getAsEnumDecl())
2358 return ED->isComplete() && ED->getIntegerType()->isBooleanType();
2359 if (const auto *IT = dyn_cast<BitIntType>(CanonicalType))
2360 return IT->getNumBits() == 1;
2361 return isBooleanType();
2362}
2363
2365 assert(isScalarType());
2366
2367 const Type *T = CanonicalType.getTypePtr();
2368 if (const auto *BT = dyn_cast<BuiltinType>(T)) {
2369 if (BT->getKind() == BuiltinType::Bool)
2370 return STK_Bool;
2371 if (BT->getKind() == BuiltinType::NullPtr)
2372 return STK_CPointer;
2373 if (BT->isInteger())
2374 return STK_Integral;
2375 if (BT->isFloatingPoint())
2376 return STK_Floating;
2377 if (BT->isFixedPointType())
2378 return STK_FixedPoint;
2379 llvm_unreachable("unknown scalar builtin type");
2380 } else if (isa<PointerType>(T)) {
2381 return STK_CPointer;
2382 } else if (isa<BlockPointerType>(T)) {
2383 return STK_BlockPointer;
2384 } else if (isa<ObjCObjectPointerType>(T)) {
2385 return STK_ObjCObjectPointer;
2386 } else if (isa<MemberPointerType>(T)) {
2387 return STK_MemberPointer;
2388 } else if (isa<EnumType>(T)) {
2389 assert(T->castAsEnumDecl()->isComplete());
2390 return STK_Integral;
2391 } else if (const auto *CT = dyn_cast<ComplexType>(T)) {
2392 if (CT->getElementType()->isRealFloatingType())
2393 return STK_FloatingComplex;
2394 return STK_IntegralComplex;
2395 } else if (isBitIntType()) {
2396 return STK_Integral;
2397 }
2398
2399 llvm_unreachable("unknown scalar type");
2400}
2401
2402/// Determines whether the type is a C++ aggregate type or C
2403/// aggregate or union type.
2404///
2405/// An aggregate type is an array or a class type (struct, union, or
2406/// class) that has no user-declared constructors, no private or
2407/// protected non-static data members, no base classes, and no virtual
2408/// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type
2409/// subsumes the notion of C aggregates (C99 6.2.5p21) because it also
2410/// includes union types.
2412 if (const auto *Record = dyn_cast<RecordType>(CanonicalType)) {
2413 if (const auto *ClassDecl =
2414 dyn_cast<CXXRecordDecl>(Record->getOriginalDecl()))
2415 return ClassDecl->isAggregate();
2416
2417 return true;
2418 }
2419
2420 return isa<ArrayType>(CanonicalType);
2421}
2422
2423/// isConstantSizeType - Return true if this is not a variable sized type,
2424/// according to the rules of C99 6.7.5p3. It is not legal to call this on
2425/// incomplete types or dependent types.
2427 assert(!isIncompleteType() && "This doesn't make sense for incomplete types");
2428 assert(!isDependentType() && "This doesn't make sense for dependent types");
2429 // The VAT must have a size, as it is known to be complete.
2430 return !isa<VariableArrayType>(CanonicalType);
2431}
2432
2433/// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1)
2434/// - a type that can describe objects, but which lacks information needed to
2435/// determine its size.
2437 if (Def)
2438 *Def = nullptr;
2439
2440 switch (CanonicalType->getTypeClass()) {
2441 default:
2442 return false;
2443 case Builtin:
2444 // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never
2445 // be completed.
2446 return isVoidType();
2447 case Enum: {
2448 auto *EnumD = castAsEnumDecl();
2449 if (Def)
2450 *Def = EnumD;
2451 return !EnumD->isComplete();
2452 }
2453 case Record: {
2454 // A tagged type (struct/union/enum/class) is incomplete if the decl is a
2455 // forward declaration, but not a full definition (C99 6.2.5p22).
2456 auto *Rec = castAsRecordDecl();
2457 if (Def)
2458 *Def = Rec;
2459 return !Rec->isCompleteDefinition();
2460 }
2461 case InjectedClassName: {
2462 auto *Rec = castAsCXXRecordDecl();
2463 if (!Rec->isBeingDefined())
2464 return false;
2465 if (Def)
2466 *Def = Rec;
2467 return true;
2468 }
2469 case ConstantArray:
2470 case VariableArray:
2471 // An array is incomplete if its element type is incomplete
2472 // (C++ [dcl.array]p1).
2473 // We don't handle dependent-sized arrays (dependent types are never treated
2474 // as incomplete).
2475 return cast<ArrayType>(CanonicalType)
2476 ->getElementType()
2477 ->isIncompleteType(Def);
2478 case IncompleteArray:
2479 // An array of unknown size is an incomplete type (C99 6.2.5p22).
2480 return true;
2481 case MemberPointer: {
2482 // Member pointers in the MS ABI have special behavior in
2483 // RequireCompleteType: they attach a MSInheritanceAttr to the CXXRecordDecl
2484 // to indicate which inheritance model to use.
2485 // The inheritance attribute might only be present on the most recent
2486 // CXXRecordDecl.
2487 const CXXRecordDecl *RD =
2488 cast<MemberPointerType>(CanonicalType)->getMostRecentCXXRecordDecl();
2489 // Member pointers with dependent class types don't get special treatment.
2490 if (!RD || RD->isDependentType())
2491 return false;
2492 ASTContext &Context = RD->getASTContext();
2493 // Member pointers not in the MS ABI don't get special treatment.
2494 if (!Context.getTargetInfo().getCXXABI().isMicrosoft())
2495 return false;
2496 // Nothing interesting to do if the inheritance attribute is already set.
2497 if (RD->hasAttr<MSInheritanceAttr>())
2498 return false;
2499 return true;
2500 }
2501 case ObjCObject:
2502 return cast<ObjCObjectType>(CanonicalType)
2503 ->getBaseType()
2504 ->isIncompleteType(Def);
2505 case ObjCInterface: {
2506 // ObjC interfaces are incomplete if they are @class, not @interface.
2508 cast<ObjCInterfaceType>(CanonicalType)->getDecl();
2509 if (Def)
2510 *Def = Interface;
2511 return !Interface->hasDefinition();
2512 }
2513 }
2514}
2515
2517 if (!isIncompleteType())
2518 return false;
2519
2520 // Forward declarations of structs, classes, enums, and unions could be later
2521 // completed in a compilation unit by providing a type definition.
2522 if (isa<TagType>(CanonicalType))
2523 return false;
2524
2525 // Other types are incompletable.
2526 //
2527 // E.g. `char[]` and `void`. The type is incomplete and no future
2528 // type declarations can make the type complete.
2529 return true;
2530}
2531
2534 return true;
2535
2536 if (const BuiltinType *BT = getAs<BuiltinType>()) {
2537 switch (BT->getKind()) {
2538 // WebAssembly reference types
2539#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2540#include "clang/Basic/WebAssemblyReferenceTypes.def"
2541 // HLSL intangible types
2542#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2543#include "clang/Basic/HLSLIntangibleTypes.def"
2544 return true;
2545 default:
2546 return false;
2547 }
2548 }
2549 return false;
2550}
2551
2553 if (const auto *BT = getAs<BuiltinType>())
2554 return BT->getKind() == BuiltinType::WasmExternRef;
2555 return false;
2556}
2557
2559 if (const auto *ATy = dyn_cast<ArrayType>(this))
2560 return ATy->getElementType().isWebAssemblyReferenceType();
2561
2562 if (const auto *PTy = dyn_cast<PointerType>(this))
2563 return PTy->getPointeeType().isWebAssemblyReferenceType();
2564
2565 return false;
2566}
2567
2569
2573
2575 if (const BuiltinType *BT = getAs<BuiltinType>()) {
2576 switch (BT->getKind()) {
2577 // SVE Types
2578#define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId) \
2579 case BuiltinType::Id: \
2580 return true;
2581#define SVE_OPAQUE_TYPE(Name, MangledName, Id, SingletonId) \
2582 case BuiltinType::Id: \
2583 return true;
2584#define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId) \
2585 case BuiltinType::Id: \
2586 return true;
2587#include "clang/Basic/AArch64ACLETypes.def"
2588 default:
2589 return false;
2590 }
2591 }
2592 return false;
2593}
2594
2596 if (const BuiltinType *BT = getAs<BuiltinType>()) {
2597 switch (BT->getKind()) {
2598#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2599#include "clang/Basic/RISCVVTypes.def"
2600 return true;
2601 default:
2602 return false;
2603 }
2604 }
2605 return false;
2606}
2607
2609 if (const BuiltinType *BT = getAs<BuiltinType>()) {
2610 switch (BT->getKind()) {
2611 case BuiltinType::SveInt8:
2612 case BuiltinType::SveInt16:
2613 case BuiltinType::SveInt32:
2614 case BuiltinType::SveInt64:
2615 case BuiltinType::SveUint8:
2616 case BuiltinType::SveUint16:
2617 case BuiltinType::SveUint32:
2618 case BuiltinType::SveUint64:
2619 case BuiltinType::SveFloat16:
2620 case BuiltinType::SveFloat32:
2621 case BuiltinType::SveFloat64:
2622 case BuiltinType::SveBFloat16:
2623 case BuiltinType::SveBool:
2624 case BuiltinType::SveBoolx2:
2625 case BuiltinType::SveBoolx4:
2626 case BuiltinType::SveMFloat8:
2627 return true;
2628 default:
2629 return false;
2630 }
2631 }
2632 return false;
2633}
2634
2636 assert(isSizelessVectorType() && "Must be sizeless vector type");
2637 // Currently supports SVE and RVV
2639 return getSveEltType(Ctx);
2640
2642 return getRVVEltType(Ctx);
2643
2644 llvm_unreachable("Unhandled type");
2645}
2646
2648 assert(isSveVLSBuiltinType() && "unsupported type!");
2649
2650 const BuiltinType *BTy = castAs<BuiltinType>();
2651 if (BTy->getKind() == BuiltinType::SveBool)
2652 // Represent predicates as i8 rather than i1 to avoid any layout issues.
2653 // The type is bitcasted to a scalable predicate type when casting between
2654 // scalable and fixed-length vectors.
2655 return Ctx.UnsignedCharTy;
2656 else
2657 return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType;
2658}
2659
2661 if (const BuiltinType *BT = getAs<BuiltinType>()) {
2662 switch (BT->getKind()) {
2663#define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, \
2664 IsFP, IsBF) \
2665 case BuiltinType::Id: \
2666 return NF == 1;
2667#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
2668 case BuiltinType::Id: \
2669 return true;
2670#include "clang/Basic/RISCVVTypes.def"
2671 default:
2672 return false;
2673 }
2674 }
2675 return false;
2676}
2677
2679 assert(isRVVVLSBuiltinType() && "unsupported type!");
2680
2681 const BuiltinType *BTy = castAs<BuiltinType>();
2682
2683 switch (BTy->getKind()) {
2684#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
2685 case BuiltinType::Id: \
2686 return Ctx.UnsignedCharTy;
2687 default:
2688 return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType;
2689#include "clang/Basic/RISCVVTypes.def"
2690 }
2691
2692 llvm_unreachable("Unhandled type");
2693}
2694
2695bool QualType::isPODType(const ASTContext &Context) const {
2696 // C++11 has a more relaxed definition of POD.
2697 if (Context.getLangOpts().CPlusPlus11)
2698 return isCXX11PODType(Context);
2699
2700 return isCXX98PODType(Context);
2701}
2702
2703bool QualType::isCXX98PODType(const ASTContext &Context) const {
2704 // The compiler shouldn't query this for incomplete types, but the user might.
2705 // We return false for that case. Except for incomplete arrays of PODs, which
2706 // are PODs according to the standard.
2707 if (isNull())
2708 return false;
2709
2710 if ((*this)->isIncompleteArrayType())
2711 return Context.getBaseElementType(*this).isCXX98PODType(Context);
2712
2713 if ((*this)->isIncompleteType())
2714 return false;
2715
2717 return false;
2718
2719 QualType CanonicalType = getTypePtr()->CanonicalType;
2720
2721 // Any type that is, or contains, address discriminated data is never POD.
2722 if (Context.containsAddressDiscriminatedPointerAuth(CanonicalType))
2723 return false;
2724
2725 switch (CanonicalType->getTypeClass()) {
2726 // Everything not explicitly mentioned is not POD.
2727 default:
2728 return false;
2729 case Type::VariableArray:
2730 case Type::ConstantArray:
2731 // IncompleteArray is handled above.
2732 return Context.getBaseElementType(*this).isCXX98PODType(Context);
2733
2734 case Type::ObjCObjectPointer:
2735 case Type::BlockPointer:
2736 case Type::Builtin:
2737 case Type::Complex:
2738 case Type::Pointer:
2739 case Type::MemberPointer:
2740 case Type::Vector:
2741 case Type::ExtVector:
2742 case Type::BitInt:
2743 return true;
2744
2745 case Type::Enum:
2746 return true;
2747
2748 case Type::Record:
2749 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(
2750 cast<RecordType>(CanonicalType)->getOriginalDecl()))
2751 return ClassDecl->isPOD();
2752
2753 // C struct/union is POD.
2754 return true;
2755 }
2756}
2757
2758bool QualType::isTrivialType(const ASTContext &Context) const {
2759 // The compiler shouldn't query this for incomplete types, but the user might.
2760 // We return false for that case. Except for incomplete arrays of PODs, which
2761 // are PODs according to the standard.
2762 if (isNull())
2763 return false;
2764
2765 if ((*this)->isArrayType())
2766 return Context.getBaseElementType(*this).isTrivialType(Context);
2767
2768 if ((*this)->isSizelessBuiltinType())
2769 return true;
2770
2771 // Return false for incomplete types after skipping any incomplete array
2772 // types which are expressly allowed by the standard and thus our API.
2773 if ((*this)->isIncompleteType())
2774 return false;
2775
2777 return false;
2778
2779 QualType CanonicalType = getTypePtr()->CanonicalType;
2780 if (CanonicalType->isDependentType())
2781 return false;
2782
2783 // Any type that is, or contains, address discriminated data is never a
2784 // trivial type.
2785 if (Context.containsAddressDiscriminatedPointerAuth(CanonicalType))
2786 return false;
2787
2788 // C++0x [basic.types]p9:
2789 // Scalar types, trivial class types, arrays of such types, and
2790 // cv-qualified versions of these types are collectively called trivial
2791 // types.
2792
2793 // As an extension, Clang treats vector types as Scalar types.
2794 if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
2795 return true;
2796
2797 if (const auto *ClassDecl = CanonicalType->getAsCXXRecordDecl()) {
2798 // C++20 [class]p6:
2799 // A trivial class is a class that is trivially copyable, and
2800 // has one or more eligible default constructors such that each is
2801 // trivial.
2802 // FIXME: We should merge this definition of triviality into
2803 // CXXRecordDecl::isTrivial. Currently it computes the wrong thing.
2804 return ClassDecl->hasTrivialDefaultConstructor() &&
2805 !ClassDecl->hasNonTrivialDefaultConstructor() &&
2806 ClassDecl->isTriviallyCopyable();
2807 }
2808
2809 if (isa<RecordType>(CanonicalType))
2810 return true;
2811
2812 // No other types can match.
2813 return false;
2814}
2815
2817 const ASTContext &Context,
2818 bool IsCopyConstructible) {
2819 if (type->isArrayType())
2820 return isTriviallyCopyableTypeImpl(Context.getBaseElementType(type),
2821 Context, IsCopyConstructible);
2822
2823 if (type.hasNonTrivialObjCLifetime())
2824 return false;
2825
2826 // C++11 [basic.types]p9 - See Core 2094
2827 // Scalar types, trivially copyable class types, arrays of such types, and
2828 // cv-qualified versions of these types are collectively
2829 // called trivially copy constructible types.
2830
2831 QualType CanonicalType = type.getCanonicalType();
2832 if (CanonicalType->isDependentType())
2833 return false;
2834
2835 if (CanonicalType->isSizelessBuiltinType())
2836 return true;
2837
2838 // Return false for incomplete types after skipping any incomplete array types
2839 // which are expressly allowed by the standard and thus our API.
2840 if (CanonicalType->isIncompleteType())
2841 return false;
2842
2843 if (CanonicalType.hasAddressDiscriminatedPointerAuth())
2844 return false;
2845
2846 // As an extension, Clang treats vector types as Scalar types.
2847 if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
2848 return true;
2849
2850 // Mfloat8 type is a special case as it not scalar, but is still trivially
2851 // copyable.
2852 if (CanonicalType->isMFloat8Type())
2853 return true;
2854
2855 if (const auto *RD = CanonicalType->getAsRecordDecl()) {
2856 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2857 if (IsCopyConstructible)
2858 return ClassDecl->isTriviallyCopyConstructible();
2859 return ClassDecl->isTriviallyCopyable();
2860 }
2861 return !RD->isNonTrivialToPrimitiveCopy();
2862 }
2863 // No other types can match.
2864 return false;
2865}
2866
2868 return isTriviallyCopyableTypeImpl(*this, Context,
2869 /*IsCopyConstructible=*/false);
2870}
2871
2872// FIXME: each call will trigger a full computation, cache the result.
2874 auto CanonicalType = getCanonicalType();
2875 if (CanonicalType.hasNonTrivialObjCLifetime())
2876 return false;
2877 if (CanonicalType->isArrayType())
2878 return Context.getBaseElementType(CanonicalType)
2879 .isBitwiseCloneableType(Context);
2880
2881 if (CanonicalType->isIncompleteType())
2882 return false;
2883
2884 // Any type that is, or contains, address discriminated data is never
2885 // bitwise clonable.
2886 if (Context.containsAddressDiscriminatedPointerAuth(CanonicalType))
2887 return false;
2888
2889 const auto *RD = CanonicalType->getAsRecordDecl(); // struct/union/class
2890 if (!RD)
2891 return true;
2892
2893 // Never allow memcpy when we're adding poisoned padding bits to the struct.
2894 // Accessing these posioned bits will trigger false alarms on
2895 // SanitizeAddressFieldPadding etc.
2896 if (RD->mayInsertExtraPadding())
2897 return false;
2898
2899 for (auto *const Field : RD->fields()) {
2900 if (!Field->getType().isBitwiseCloneableType(Context))
2901 return false;
2902 }
2903
2904 if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
2905 for (auto Base : CXXRD->bases())
2906 if (!Base.getType().isBitwiseCloneableType(Context))
2907 return false;
2908 for (auto VBase : CXXRD->vbases())
2909 if (!VBase.getType().isBitwiseCloneableType(Context))
2910 return false;
2911 }
2912 return true;
2913}
2914
2916 const ASTContext &Context) const {
2917 return isTriviallyCopyableTypeImpl(*this, Context,
2918 /*IsCopyConstructible=*/true);
2919}
2920
2922 return !Context.getLangOpts().ObjCAutoRefCount &&
2923 Context.getLangOpts().ObjCWeak &&
2925}
2926
2928 const RecordDecl *RD) {
2930}
2931
2934}
2935
2938}
2939
2943
2947
2952
2955 if (const auto *RD =
2956 getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
2958 return PDIK_Struct;
2959
2960 switch (getQualifiers().getObjCLifetime()) {
2962 return PDIK_ARCStrong;
2964 return PDIK_ARCWeak;
2965 default:
2966 return PDIK_Trivial;
2967 }
2968}
2969
2971 if (const auto *RD =
2972 getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
2974 return PCK_Struct;
2975
2977 switch (Qs.getObjCLifetime()) {
2979 return PCK_ARCStrong;
2981 return PCK_ARCWeak;
2982 default:
2984 return PCK_PtrAuth;
2986 }
2987}
2988
2993
2994bool Type::isLiteralType(const ASTContext &Ctx) const {
2995 if (isDependentType())
2996 return false;
2997
2998 // C++1y [basic.types]p10:
2999 // A type is a literal type if it is:
3000 // -- cv void; or
3001 if (Ctx.getLangOpts().CPlusPlus14 && isVoidType())
3002 return true;
3003
3004 // C++11 [basic.types]p10:
3005 // A type is a literal type if it is:
3006 // [...]
3007 // -- an array of literal type other than an array of runtime bound; or
3008 if (isVariableArrayType())
3009 return false;
3010 const Type *BaseTy = getBaseElementTypeUnsafe();
3011 assert(BaseTy && "NULL element type");
3012
3013 // Return false for incomplete types after skipping any incomplete array
3014 // types; those are expressly allowed by the standard and thus our API.
3015 if (BaseTy->isIncompleteType())
3016 return false;
3017
3018 // C++11 [basic.types]p10:
3019 // A type is a literal type if it is:
3020 // -- a scalar type; or
3021 // As an extension, Clang treats vector types and complex types as
3022 // literal types.
3023 if (BaseTy->isScalarType() || BaseTy->isVectorType() ||
3024 BaseTy->isAnyComplexType())
3025 return true;
3026 // -- a reference type; or
3027 if (BaseTy->isReferenceType())
3028 return true;
3029 // -- a class type that has all of the following properties:
3030 if (const auto *RD = BaseTy->getAsRecordDecl()) {
3031 // -- a trivial destructor,
3032 // -- every constructor call and full-expression in the
3033 // brace-or-equal-initializers for non-static data members (if any)
3034 // is a constant expression,
3035 // -- it is an aggregate type or has at least one constexpr
3036 // constructor or constructor template that is not a copy or move
3037 // constructor, and
3038 // -- all non-static data members and base classes of literal types
3039 //
3040 // We resolve DR1361 by ignoring the second bullet.
3041 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD))
3042 return ClassDecl->isLiteral();
3043
3044 return true;
3045 }
3046
3047 // We treat _Atomic T as a literal type if T is a literal type.
3048 if (const auto *AT = BaseTy->getAs<AtomicType>())
3049 return AT->getValueType()->isLiteralType(Ctx);
3050
3051 // If this type hasn't been deduced yet, then conservatively assume that
3052 // it'll work out to be a literal type.
3054 return true;
3055
3056 return false;
3057}
3058
3060 // C++20 [temp.param]p6:
3061 // A structural type is one of the following:
3062 // -- a scalar type; or
3063 // -- a vector type [Clang extension]; or
3064 if (isScalarType() || isVectorType())
3065 return true;
3066 // -- an lvalue reference type; or
3068 return true;
3069 // -- a literal class type [...under some conditions]
3070 if (const CXXRecordDecl *RD = getAsCXXRecordDecl())
3071 return RD->isStructural();
3072 return false;
3073}
3074
3076 if (isDependentType())
3077 return false;
3078
3079 // C++0x [basic.types]p9:
3080 // Scalar types, standard-layout class types, arrays of such types, and
3081 // cv-qualified versions of these types are collectively called
3082 // standard-layout types.
3083 const Type *BaseTy = getBaseElementTypeUnsafe();
3084 assert(BaseTy && "NULL element type");
3085
3086 // Return false for incomplete types after skipping any incomplete array
3087 // types which are expressly allowed by the standard and thus our API.
3088 if (BaseTy->isIncompleteType())
3089 return false;
3090
3091 // As an extension, Clang treats vector types as Scalar types.
3092 if (BaseTy->isScalarType() || BaseTy->isVectorType())
3093 return true;
3094 if (const auto *RD = BaseTy->getAsRecordDecl()) {
3095 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD);
3096 ClassDecl && !ClassDecl->isStandardLayout())
3097 return false;
3098
3099 // Default to 'true' for non-C++ class types.
3100 // FIXME: This is a bit dubious, but plain C structs should trivially meet
3101 // all the requirements of standard layout classes.
3102 return true;
3103 }
3104
3105 // No other types can match.
3106 return false;
3107}
3108
3109// This is effectively the intersection of isTrivialType and
3110// isStandardLayoutType. We implement it directly to avoid redundant
3111// conversions from a type to a CXXRecordDecl.
3112bool QualType::isCXX11PODType(const ASTContext &Context) const {
3113 const Type *ty = getTypePtr();
3114 if (ty->isDependentType())
3115 return false;
3116
3118 return false;
3119
3120 // C++11 [basic.types]p9:
3121 // Scalar types, POD classes, arrays of such types, and cv-qualified
3122 // versions of these types are collectively called trivial types.
3123 const Type *BaseTy = ty->getBaseElementTypeUnsafe();
3124 assert(BaseTy && "NULL element type");
3125
3126 if (BaseTy->isSizelessBuiltinType())
3127 return true;
3128
3129 // Return false for incomplete types after skipping any incomplete array
3130 // types which are expressly allowed by the standard and thus our API.
3131 if (BaseTy->isIncompleteType())
3132 return false;
3133
3134 // Any type that is, or contains, address discriminated data is non-POD.
3135 if (Context.containsAddressDiscriminatedPointerAuth(*this))
3136 return false;
3137
3138 // As an extension, Clang treats vector types as Scalar types.
3139 if (BaseTy->isScalarType() || BaseTy->isVectorType())
3140 return true;
3141 if (const auto *RD = BaseTy->getAsRecordDecl()) {
3142 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
3143 // C++11 [class]p10:
3144 // A POD struct is a non-union class that is both a trivial class [...]
3145 if (!ClassDecl->isTrivial())
3146 return false;
3147
3148 // C++11 [class]p10:
3149 // A POD struct is a non-union class that is both a trivial class and
3150 // a standard-layout class [...]
3151 if (!ClassDecl->isStandardLayout())
3152 return false;
3153
3154 // C++11 [class]p10:
3155 // A POD struct is a non-union class that is both a trivial class and
3156 // a standard-layout class, and has no non-static data members of type
3157 // non-POD struct, non-POD union (or array of such types). [...]
3158 //
3159 // We don't directly query the recursive aspect as the requirements for
3160 // both standard-layout classes and trivial classes apply recursively
3161 // already.
3162 }
3163
3164 return true;
3165 }
3166
3167 // No other types can match.
3168 return false;
3169}
3170
3171bool Type::isNothrowT() const {
3172 if (const auto *RD = getAsCXXRecordDecl()) {
3173 IdentifierInfo *II = RD->getIdentifier();
3174 if (II && II->isStr("nothrow_t") && RD->isInStdNamespace())
3175 return true;
3176 }
3177 return false;
3178}
3179
3180bool Type::isAlignValT() const {
3181 if (const auto *ET = getAsCanonical<EnumType>()) {
3182 const auto *ED = ET->getOriginalDecl();
3183 IdentifierInfo *II = ED->getIdentifier();
3184 if (II && II->isStr("align_val_t") && ED->isInStdNamespace())
3185 return true;
3186 }
3187 return false;
3188}
3189
3191 if (const auto *ET = getAsCanonical<EnumType>()) {
3192 const auto *ED = ET->getOriginalDecl();
3193 IdentifierInfo *II = ED->getIdentifier();
3194 if (II && II->isStr("byte") && ED->isInStdNamespace())
3195 return true;
3196 }
3197 return false;
3198}
3199
3201 // Note that this intentionally does not use the canonical type.
3202 switch (getTypeClass()) {
3203 case Builtin:
3204 case Record:
3205 case Enum:
3206 case Typedef:
3207 case Complex:
3208 case TypeOfExpr:
3209 case TypeOf:
3210 case TemplateTypeParm:
3211 case SubstTemplateTypeParm:
3212 case TemplateSpecialization:
3213 case DependentName:
3214 case ObjCInterface:
3215 case ObjCObject:
3216 return true;
3217 default:
3218 return false;
3219 }
3220}
3221
3223 switch (TypeSpec) {
3224 default:
3226 case TST_typename:
3228 case TST_class:
3230 case TST_struct:
3232 case TST_interface:
3234 case TST_union:
3236 case TST_enum:
3238 }
3239}
3240
3242 switch (TypeSpec) {
3243 case TST_class:
3244 return TagTypeKind::Class;
3245 case TST_struct:
3246 return TagTypeKind::Struct;
3247 case TST_interface:
3249 case TST_union:
3250 return TagTypeKind::Union;
3251 case TST_enum:
3252 return TagTypeKind::Enum;
3253 }
3254
3255 llvm_unreachable("Type specifier is not a tag type kind.");
3256}
3257
3260 switch (Kind) {
3261 case TagTypeKind::Class:
3267 case TagTypeKind::Union:
3269 case TagTypeKind::Enum:
3271 }
3272 llvm_unreachable("Unknown tag type kind.");
3273}
3274
3277 switch (Keyword) {
3279 return TagTypeKind::Class;
3281 return TagTypeKind::Struct;
3285 return TagTypeKind::Union;
3287 return TagTypeKind::Enum;
3288 case ElaboratedTypeKeyword::None: // Fall through.
3290 llvm_unreachable("Elaborated type keyword is not a tag type kind.");
3291 }
3292 llvm_unreachable("Unknown elaborated type keyword.");
3293}
3294
3296 switch (Keyword) {
3299 return false;
3305 return true;
3306 }
3307 llvm_unreachable("Unknown elaborated type keyword.");
3308}
3309
3311 switch (Keyword) {
3313 return {};
3315 return "typename";
3317 return "class";
3319 return "struct";
3321 return "__interface";
3323 return "union";
3325 return "enum";
3326 }
3327
3328 llvm_unreachable("Unknown elaborated type keyword.");
3329}
3330
3333 if (const auto *TST = dyn_cast<TemplateSpecializationType>(this))
3334 Keyword = TST->getKeyword();
3335 else if (const auto *DepName = dyn_cast<DependentNameType>(this))
3336 Keyword = DepName->getKeyword();
3337 else if (const auto *T = dyn_cast<TagType>(this))
3338 Keyword = T->getKeyword();
3339 else if (const auto *T = dyn_cast<TypedefType>(this))
3340 Keyword = T->getKeyword();
3341 else if (const auto *T = dyn_cast<UnresolvedUsingType>(this))
3342 Keyword = T->getKeyword();
3343 else if (const auto *T = dyn_cast<UsingType>(this))
3344 Keyword = T->getKeyword();
3345 else
3346 return false;
3347
3349}
3350
3351const char *Type::getTypeClassName() const {
3352 switch (TypeBits.TC) {
3353#define ABSTRACT_TYPE(Derived, Base)
3354#define TYPE(Derived, Base) \
3355 case Derived: \
3356 return #Derived;
3357#include "clang/AST/TypeNodes.inc"
3358 }
3359
3360 llvm_unreachable("Invalid type class.");
3361}
3362
3363StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
3364 switch (getKind()) {
3365 case Void:
3366 return "void";
3367 case Bool:
3368 return Policy.Bool ? "bool" : "_Bool";
3369 case Char_S:
3370 return "char";
3371 case Char_U:
3372 return "char";
3373 case SChar:
3374 return "signed char";
3375 case Short:
3376 return "short";
3377 case Int:
3378 return "int";
3379 case Long:
3380 return "long";
3381 case LongLong:
3382 return "long long";
3383 case Int128:
3384 return "__int128";
3385 case UChar:
3386 return "unsigned char";
3387 case UShort:
3388 return "unsigned short";
3389 case UInt:
3390 return "unsigned int";
3391 case ULong:
3392 return "unsigned long";
3393 case ULongLong:
3394 return "unsigned long long";
3395 case UInt128:
3396 return "unsigned __int128";
3397 case Half:
3398 return Policy.Half ? "half" : "__fp16";
3399 case BFloat16:
3400 return "__bf16";
3401 case Float:
3402 return "float";
3403 case Double:
3404 return "double";
3405 case LongDouble:
3406 return "long double";
3407 case ShortAccum:
3408 return "short _Accum";
3409 case Accum:
3410 return "_Accum";
3411 case LongAccum:
3412 return "long _Accum";
3413 case UShortAccum:
3414 return "unsigned short _Accum";
3415 case UAccum:
3416 return "unsigned _Accum";
3417 case ULongAccum:
3418 return "unsigned long _Accum";
3419 case BuiltinType::ShortFract:
3420 return "short _Fract";
3421 case BuiltinType::Fract:
3422 return "_Fract";
3423 case BuiltinType::LongFract:
3424 return "long _Fract";
3425 case BuiltinType::UShortFract:
3426 return "unsigned short _Fract";
3427 case BuiltinType::UFract:
3428 return "unsigned _Fract";
3429 case BuiltinType::ULongFract:
3430 return "unsigned long _Fract";
3431 case BuiltinType::SatShortAccum:
3432 return "_Sat short _Accum";
3433 case BuiltinType::SatAccum:
3434 return "_Sat _Accum";
3435 case BuiltinType::SatLongAccum:
3436 return "_Sat long _Accum";
3437 case BuiltinType::SatUShortAccum:
3438 return "_Sat unsigned short _Accum";
3439 case BuiltinType::SatUAccum:
3440 return "_Sat unsigned _Accum";
3441 case BuiltinType::SatULongAccum:
3442 return "_Sat unsigned long _Accum";
3443 case BuiltinType::SatShortFract:
3444 return "_Sat short _Fract";
3445 case BuiltinType::SatFract:
3446 return "_Sat _Fract";
3447 case BuiltinType::SatLongFract:
3448 return "_Sat long _Fract";
3449 case BuiltinType::SatUShortFract:
3450 return "_Sat unsigned short _Fract";
3451 case BuiltinType::SatUFract:
3452 return "_Sat unsigned _Fract";
3453 case BuiltinType::SatULongFract:
3454 return "_Sat unsigned long _Fract";
3455 case Float16:
3456 return "_Float16";
3457 case Float128:
3458 return "__float128";
3459 case Ibm128:
3460 return "__ibm128";
3461 case WChar_S:
3462 case WChar_U:
3463 return Policy.MSWChar ? "__wchar_t" : "wchar_t";
3464 case Char8:
3465 return "char8_t";
3466 case Char16:
3467 return "char16_t";
3468 case Char32:
3469 return "char32_t";
3470 case NullPtr:
3471 return Policy.NullptrTypeInNamespace ? "std::nullptr_t" : "nullptr_t";
3472 case Overload:
3473 return "<overloaded function type>";
3474 case BoundMember:
3475 return "<bound member function type>";
3476 case UnresolvedTemplate:
3477 return "<unresolved template type>";
3478 case PseudoObject:
3479 return "<pseudo-object type>";
3480 case Dependent:
3481 return "<dependent type>";
3482 case UnknownAny:
3483 return "<unknown type>";
3484 case ARCUnbridgedCast:
3485 return "<ARC unbridged cast type>";
3486 case BuiltinFn:
3487 return "<builtin fn type>";
3488 case ObjCId:
3489 return "id";
3490 case ObjCClass:
3491 return "Class";
3492 case ObjCSel:
3493 return "SEL";
3494#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3495 case Id: \
3496 return "__" #Access " " #ImgType "_t";
3497#include "clang/Basic/OpenCLImageTypes.def"
3498 case OCLSampler:
3499 return "sampler_t";
3500 case OCLEvent:
3501 return "event_t";
3502 case OCLClkEvent:
3503 return "clk_event_t";
3504 case OCLQueue:
3505 return "queue_t";
3506 case OCLReserveID:
3507 return "reserve_id_t";
3508 case IncompleteMatrixIdx:
3509 return "<incomplete matrix index type>";
3510 case ArraySection:
3511 return "<array section type>";
3512 case OMPArrayShaping:
3513 return "<OpenMP array shaping type>";
3514 case OMPIterator:
3515 return "<OpenMP iterator type>";
3516#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
3517 case Id: \
3518 return #ExtType;
3519#include "clang/Basic/OpenCLExtensionTypes.def"
3520#define SVE_TYPE(Name, Id, SingletonId) \
3521 case Id: \
3522 return #Name;
3523#include "clang/Basic/AArch64ACLETypes.def"
3524#define PPC_VECTOR_TYPE(Name, Id, Size) \
3525 case Id: \
3526 return #Name;
3527#include "clang/Basic/PPCTypes.def"
3528#define RVV_TYPE(Name, Id, SingletonId) \
3529 case Id: \
3530 return Name;
3531#include "clang/Basic/RISCVVTypes.def"
3532#define WASM_TYPE(Name, Id, SingletonId) \
3533 case Id: \
3534 return Name;
3535#include "clang/Basic/WebAssemblyReferenceTypes.def"
3536#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \
3537 case Id: \
3538 return Name;
3539#include "clang/Basic/AMDGPUTypes.def"
3540#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
3541 case Id: \
3542 return #Name;
3543#include "clang/Basic/HLSLIntangibleTypes.def"
3544 }
3545
3546 llvm_unreachable("Invalid builtin type.");
3547}
3548
3550 // We never wrap type sugar around a PackExpansionType.
3551 if (auto *PET = dyn_cast<PackExpansionType>(getTypePtr()))
3552 return PET->getPattern();
3553 return *this;
3554}
3555
3557 if (const auto *RefType = getTypePtr()->getAs<ReferenceType>())
3558 return RefType->getPointeeType();
3559
3560 // C++0x [basic.lval]:
3561 // Class prvalues can have cv-qualified types; non-class prvalues always
3562 // have cv-unqualified types.
3563 //
3564 // See also C99 6.3.2.1p2.
3565 if (!Context.getLangOpts().CPlusPlus ||
3566 (!getTypePtr()->isDependentType() && !getTypePtr()->isRecordType()))
3567 return getUnqualifiedType();
3568
3569 return *this;
3570}
3571
3573 if (const auto *FPT = getAs<FunctionProtoType>())
3574 return FPT->hasCFIUncheckedCallee();
3575 return false;
3576}
3577
3579 switch (CC) {
3580 case CC_C:
3581 return "cdecl";
3582 case CC_X86StdCall:
3583 return "stdcall";
3584 case CC_X86FastCall:
3585 return "fastcall";
3586 case CC_X86ThisCall:
3587 return "thiscall";
3588 case CC_X86Pascal:
3589 return "pascal";
3590 case CC_X86VectorCall:
3591 return "vectorcall";
3592 case CC_Win64:
3593 return "ms_abi";
3594 case CC_X86_64SysV:
3595 return "sysv_abi";
3596 case CC_X86RegCall:
3597 return "regcall";
3598 case CC_AAPCS:
3599 return "aapcs";
3600 case CC_AAPCS_VFP:
3601 return "aapcs-vfp";
3603 return "aarch64_vector_pcs";
3604 case CC_AArch64SVEPCS:
3605 return "aarch64_sve_pcs";
3606 case CC_IntelOclBicc:
3607 return "intel_ocl_bicc";
3608 case CC_SpirFunction:
3609 return "spir_function";
3610 case CC_DeviceKernel:
3611 return "device_kernel";
3612 case CC_Swift:
3613 return "swiftcall";
3614 case CC_SwiftAsync:
3615 return "swiftasynccall";
3616 case CC_PreserveMost:
3617 return "preserve_most";
3618 case CC_PreserveAll:
3619 return "preserve_all";
3620 case CC_M68kRTD:
3621 return "m68k_rtd";
3622 case CC_PreserveNone:
3623 return "preserve_none";
3624 // clang-format off
3625 case CC_RISCVVectorCall: return "riscv_vector_cc";
3626#define CC_VLS_CASE(ABI_VLEN) \
3627 case CC_RISCVVLSCall_##ABI_VLEN: return "riscv_vls_cc(" #ABI_VLEN ")";
3628 CC_VLS_CASE(32)
3629 CC_VLS_CASE(64)
3630 CC_VLS_CASE(128)
3631 CC_VLS_CASE(256)
3632 CC_VLS_CASE(512)
3633 CC_VLS_CASE(1024)
3634 CC_VLS_CASE(2048)
3635 CC_VLS_CASE(4096)
3636 CC_VLS_CASE(8192)
3637 CC_VLS_CASE(16384)
3638 CC_VLS_CASE(32768)
3639 CC_VLS_CASE(65536)
3640#undef CC_VLS_CASE
3641 // clang-format on
3642 }
3643
3644 llvm_unreachable("Invalid calling convention.");
3645}
3646
3653
3654FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
3655 QualType canonical,
3656 const ExtProtoInfo &epi)
3657 : FunctionType(FunctionProto, result, canonical, result->getDependence(),
3658 epi.ExtInfo) {
3659 FunctionTypeBits.FastTypeQuals = epi.TypeQuals.getFastQualifiers();
3660 FunctionTypeBits.RefQualifier = epi.RefQualifier;
3661 FunctionTypeBits.NumParams = params.size();
3662 assert(getNumParams() == params.size() && "NumParams overflow!");
3663 FunctionTypeBits.ExceptionSpecType = epi.ExceptionSpec.Type;
3664 FunctionTypeBits.HasExtParameterInfos = !!epi.ExtParameterInfos;
3665 FunctionTypeBits.Variadic = epi.Variadic;
3666 FunctionTypeBits.HasTrailingReturn = epi.HasTrailingReturn;
3667 FunctionTypeBits.CFIUncheckedCallee = epi.CFIUncheckedCallee;
3668
3670 FunctionTypeBits.HasExtraBitfields = true;
3671 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3672 ExtraBits = FunctionTypeExtraBitfields();
3673 } else {
3674 FunctionTypeBits.HasExtraBitfields = false;
3675 }
3676
3677 // Propagate any extra attribute information.
3679 auto &ExtraAttrInfo = *getTrailingObjects<FunctionTypeExtraAttributeInfo>();
3680 ExtraAttrInfo.CFISalt = epi.ExtraAttributeInfo.CFISalt;
3681
3682 // Also set the bit in FunctionTypeExtraBitfields.
3683 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3684 ExtraBits.HasExtraAttributeInfo = true;
3685 }
3686
3688 auto &ArmTypeAttrs = *getTrailingObjects<FunctionTypeArmAttributes>();
3689 ArmTypeAttrs = FunctionTypeArmAttributes();
3690
3691 // Also set the bit in FunctionTypeExtraBitfields
3692 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3693 ExtraBits.HasArmTypeAttributes = true;
3694 }
3695
3696 // Fill in the trailing argument array.
3697 auto *argSlot = getTrailingObjects<QualType>();
3698 for (unsigned i = 0; i != getNumParams(); ++i) {
3699 addDependence(params[i]->getDependence() &
3700 ~TypeDependence::VariablyModified);
3701 argSlot[i] = params[i];
3702 }
3703
3704 // Propagate the SME ACLE attributes.
3706 auto &ArmTypeAttrs = *getTrailingObjects<FunctionTypeArmAttributes>();
3708 "Not enough bits to encode SME attributes");
3709 ArmTypeAttrs.AArch64SMEAttributes = epi.AArch64SMEAttributes;
3710 }
3711
3712 // Fill in the exception type array if present.
3714 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3715 size_t NumExceptions = epi.ExceptionSpec.Exceptions.size();
3716 assert(NumExceptions <= 1023 && "Not enough bits to encode exceptions");
3717 ExtraBits.NumExceptionType = NumExceptions;
3718
3719 assert(hasExtraBitfields() && "missing trailing extra bitfields!");
3720 auto *exnSlot =
3721 reinterpret_cast<QualType *>(getTrailingObjects<ExceptionType>());
3722 unsigned I = 0;
3723 for (QualType ExceptionType : epi.ExceptionSpec.Exceptions) {
3724 // Note that, before C++17, a dependent exception specification does
3725 // *not* make a type dependent; it's not even part of the C++ type
3726 // system.
3728 ExceptionType->getDependence() &
3729 (TypeDependence::Instantiation | TypeDependence::UnexpandedPack));
3730
3731 exnSlot[I++] = ExceptionType;
3732 }
3733 }
3734 // Fill in the Expr * in the exception specification if present.
3736 assert(epi.ExceptionSpec.NoexceptExpr && "computed noexcept with no expr");
3739
3740 // Store the noexcept expression and context.
3741 *getTrailingObjects<Expr *>() = epi.ExceptionSpec.NoexceptExpr;
3742
3745 (TypeDependence::Instantiation | TypeDependence::UnexpandedPack));
3746 }
3747 // Fill in the FunctionDecl * in the exception specification if present.
3749 // Store the function decl from which we will resolve our
3750 // exception specification.
3751 auto **slot = getTrailingObjects<FunctionDecl *>();
3752 slot[0] = epi.ExceptionSpec.SourceDecl;
3753 slot[1] = epi.ExceptionSpec.SourceTemplate;
3754 // This exception specification doesn't make the type dependent, because
3755 // it's not instantiated as part of instantiating the type.
3756 } else if (getExceptionSpecType() == EST_Unevaluated) {
3757 // Store the function decl from which we will resolve our
3758 // exception specification.
3759 auto **slot = getTrailingObjects<FunctionDecl *>();
3760 slot[0] = epi.ExceptionSpec.SourceDecl;
3761 }
3762
3763 // If this is a canonical type, and its exception specification is dependent,
3764 // then it's a dependent type. This only happens in C++17 onwards.
3765 if (isCanonicalUnqualified()) {
3768 assert(hasDependentExceptionSpec() && "type should not be canonical");
3769 addDependence(TypeDependence::DependentInstantiation);
3770 }
3771 } else if (getCanonicalTypeInternal()->isDependentType()) {
3772 // Ask our canonical type whether our exception specification was dependent.
3773 addDependence(TypeDependence::DependentInstantiation);
3774 }
3775
3776 // Fill in the extra parameter info if present.
3777 if (epi.ExtParameterInfos) {
3778 auto *extParamInfos = getTrailingObjects<ExtParameterInfo>();
3779 for (unsigned i = 0; i != getNumParams(); ++i)
3780 extParamInfos[i] = epi.ExtParameterInfos[i];
3781 }
3782
3783 if (epi.TypeQuals.hasNonFastQualifiers()) {
3784 FunctionTypeBits.HasExtQuals = 1;
3785 *getTrailingObjects<Qualifiers>() = epi.TypeQuals;
3786 } else {
3787 FunctionTypeBits.HasExtQuals = 0;
3788 }
3789
3790 // Fill in the Ellipsis location info if present.
3791 if (epi.Variadic) {
3792 auto &EllipsisLoc = *getTrailingObjects<SourceLocation>();
3793 EllipsisLoc = epi.EllipsisLoc;
3794 }
3795
3796 if (!epi.FunctionEffects.empty()) {
3797 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3798 size_t EffectsCount = epi.FunctionEffects.size();
3799 ExtraBits.NumFunctionEffects = EffectsCount;
3800 assert(ExtraBits.NumFunctionEffects == EffectsCount &&
3801 "effect bitfield overflow");
3802
3803 ArrayRef<FunctionEffect> SrcFX = epi.FunctionEffects.effects();
3804 auto *DestFX = getTrailingObjects<FunctionEffect>();
3805 llvm::uninitialized_copy(SrcFX, DestFX);
3806
3807 ArrayRef<EffectConditionExpr> SrcConds = epi.FunctionEffects.conditions();
3808 if (!SrcConds.empty()) {
3809 ExtraBits.EffectsHaveConditions = true;
3810 auto *DestConds = getTrailingObjects<EffectConditionExpr>();
3811 llvm::uninitialized_copy(SrcConds, DestConds);
3812 assert(llvm::any_of(SrcConds,
3813 [](const EffectConditionExpr &EC) {
3814 if (const Expr *E = EC.getCondition())
3815 return E->isTypeDependent() ||
3816 E->isValueDependent();
3817 return false;
3818 }) &&
3819 "expected a dependent expression among the conditions");
3820 addDependence(TypeDependence::DependentInstantiation);
3821 }
3822 }
3823}
3824
3826 if (Expr *NE = getNoexceptExpr())
3827 return NE->isValueDependent();
3828 for (QualType ET : exceptions())
3829 // A pack expansion with a non-dependent pattern is still dependent,
3830 // because we don't know whether the pattern is in the exception spec
3831 // or not (that depends on whether the pack has 0 expansions).
3832 if (ET->isDependentType() || ET->getAs<PackExpansionType>())
3833 return true;
3834 return false;
3835}
3836
3838 if (Expr *NE = getNoexceptExpr())
3839 return NE->isInstantiationDependent();
3840 for (QualType ET : exceptions())
3842 return true;
3843 return false;
3844}
3845
3847 switch (getExceptionSpecType()) {
3848 case EST_Unparsed:
3849 case EST_Unevaluated:
3850 llvm_unreachable("should not call this with unresolved exception specs");
3851
3852 case EST_DynamicNone:
3853 case EST_BasicNoexcept:
3854 case EST_NoexceptTrue:
3855 case EST_NoThrow:
3856 return CT_Cannot;
3857
3858 case EST_None:
3859 case EST_MSAny:
3860 case EST_NoexceptFalse:
3861 return CT_Can;
3862
3863 case EST_Dynamic:
3864 // A dynamic exception specification is throwing unless every exception
3865 // type is an (unexpanded) pack expansion type.
3866 for (unsigned I = 0; I != getNumExceptions(); ++I)
3868 return CT_Can;
3869 return CT_Dependent;
3870
3871 case EST_Uninstantiated:
3873 return CT_Dependent;
3874 }
3875
3876 llvm_unreachable("unexpected exception specification kind");
3877}
3878
3880 for (unsigned ArgIdx = getNumParams(); ArgIdx; --ArgIdx)
3881 if (isa<PackExpansionType>(getParamType(ArgIdx - 1)))
3882 return true;
3883
3884 return false;
3885}
3886
3887void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
3888 const QualType *ArgTys, unsigned NumParams,
3889 const ExtProtoInfo &epi,
3890 const ASTContext &Context, bool Canonical) {
3891 // We have to be careful not to get ambiguous profile encodings.
3892 // Note that valid type pointers are never ambiguous with anything else.
3893 //
3894 // The encoding grammar begins:
3895 // type type* bool int bool
3896 // If that final bool is true, then there is a section for the EH spec:
3897 // bool type*
3898 // This is followed by an optional "consumed argument" section of the
3899 // same length as the first type sequence:
3900 // bool*
3901 // This is followed by the ext info:
3902 // int
3903 // Finally we have a trailing return type flag (bool)
3904 // combined with AArch64 SME Attributes and extra attribute info, to save
3905 // space:
3906 // int
3907 // combined with any FunctionEffects
3908 //
3909 // There is no ambiguity between the consumed arguments and an empty EH
3910 // spec because of the leading 'bool' which unambiguously indicates
3911 // whether the following bool is the EH spec or part of the arguments.
3912
3913 ID.AddPointer(Result.getAsOpaquePtr());
3914 for (unsigned i = 0; i != NumParams; ++i)
3915 ID.AddPointer(ArgTys[i].getAsOpaquePtr());
3916 // This method is relatively performance sensitive, so as a performance
3917 // shortcut, use one AddInteger call instead of four for the next four
3918 // fields.
3919 assert(!(unsigned(epi.Variadic) & ~1) && !(unsigned(epi.RefQualifier) & ~3) &&
3920 !(unsigned(epi.ExceptionSpec.Type) & ~15) &&
3921 "Values larger than expected.");
3922 ID.AddInteger(unsigned(epi.Variadic) + (epi.RefQualifier << 1) +
3923 (epi.ExceptionSpec.Type << 3));
3924 ID.Add(epi.TypeQuals);
3925 if (epi.ExceptionSpec.Type == EST_Dynamic) {
3926 for (QualType Ex : epi.ExceptionSpec.Exceptions)
3927 ID.AddPointer(Ex.getAsOpaquePtr());
3928 } else if (isComputedNoexcept(epi.ExceptionSpec.Type)) {
3929 epi.ExceptionSpec.NoexceptExpr->Profile(ID, Context, Canonical);
3930 } else if (epi.ExceptionSpec.Type == EST_Uninstantiated ||
3931 epi.ExceptionSpec.Type == EST_Unevaluated) {
3932 ID.AddPointer(epi.ExceptionSpec.SourceDecl->getCanonicalDecl());
3933 }
3934 if (epi.ExtParameterInfos) {
3935 for (unsigned i = 0; i != NumParams; ++i)
3936 ID.AddInteger(epi.ExtParameterInfos[i].getOpaqueValue());
3937 }
3938
3939 epi.ExtInfo.Profile(ID);
3940 epi.ExtraAttributeInfo.Profile(ID);
3941
3942 unsigned EffectCount = epi.FunctionEffects.size();
3943 bool HasConds = !epi.FunctionEffects.Conditions.empty();
3944
3945 ID.AddInteger((EffectCount << 3) | (HasConds << 2) |
3946 (epi.AArch64SMEAttributes << 1) | epi.HasTrailingReturn);
3947 ID.AddInteger(epi.CFIUncheckedCallee);
3948
3949 for (unsigned Idx = 0; Idx != EffectCount; ++Idx) {
3950 ID.AddInteger(epi.FunctionEffects.Effects[Idx].toOpaqueInt32());
3951 if (HasConds)
3952 ID.AddPointer(epi.FunctionEffects.Conditions[Idx].getCondition());
3953 }
3954}
3955
3956void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID,
3957 const ASTContext &Ctx) {
3960}
3961
3963 : Data(D, Deref << DerefShift) {}
3964
3966 return Data.getInt() & DerefMask;
3967}
3968ValueDecl *TypeCoupledDeclRefInfo::getDecl() const { return Data.getPointer(); }
3969unsigned TypeCoupledDeclRefInfo::getInt() const { return Data.getInt(); }
3971 return Data.getOpaqueValue();
3972}
3974 const TypeCoupledDeclRefInfo &Other) const {
3975 return getOpaqueValue() == Other.getOpaqueValue();
3976}
3978 Data.setFromOpaqueValue(V);
3979}
3980
3982 QualType Canon)
3983 : Type(TC, Canon, Wrapped->getDependence()), WrappedTy(Wrapped) {}
3984
3985CountAttributedType::CountAttributedType(
3986 QualType Wrapped, QualType Canon, Expr *CountExpr, bool CountInBytes,
3987 bool OrNull, ArrayRef<TypeCoupledDeclRefInfo> CoupledDecls)
3988 : BoundsAttributedType(CountAttributed, Wrapped, Canon),
3989 CountExpr(CountExpr) {
3990 CountAttributedTypeBits.NumCoupledDecls = CoupledDecls.size();
3991 CountAttributedTypeBits.CountInBytes = CountInBytes;
3992 CountAttributedTypeBits.OrNull = OrNull;
3993 auto *DeclSlot = getTrailingObjects();
3994 llvm::copy(CoupledDecls, DeclSlot);
3995 Decls = llvm::ArrayRef(DeclSlot, CoupledDecls.size());
3996}
3997
3998StringRef CountAttributedType::getAttributeName(bool WithMacroPrefix) const {
3999// TODO: This method isn't really ideal because it doesn't return the spelling
4000// of the attribute that was used in the user's code. This method is used for
4001// diagnostics so the fact it doesn't use the spelling of the attribute in
4002// the user's code could be confusing (#113585).
4003#define ENUMERATE_ATTRS(PREFIX) \
4004 do { \
4005 if (isCountInBytes()) { \
4006 if (isOrNull()) \
4007 return PREFIX "sized_by_or_null"; \
4008 return PREFIX "sized_by"; \
4009 } \
4010 if (isOrNull()) \
4011 return PREFIX "counted_by_or_null"; \
4012 return PREFIX "counted_by"; \
4013 } while (0)
4014
4015 if (WithMacroPrefix)
4016 ENUMERATE_ATTRS("__");
4017 else
4018 ENUMERATE_ATTRS("");
4019
4020#undef ENUMERATE_ATTRS
4021}
4022
4023TypedefType::TypedefType(TypeClass TC, ElaboratedTypeKeyword Keyword,
4024 NestedNameSpecifier Qualifier,
4025 const TypedefNameDecl *D, QualType UnderlyingType,
4026 bool HasTypeDifferentFromDecl)
4028 Keyword, TC, UnderlyingType.getCanonicalType(),
4029 toSemanticDependence(UnderlyingType->getDependence()) |
4030 (Qualifier
4031 ? toTypeDependence(Qualifier.getDependence() &
4032 ~NestedNameSpecifierDependence::Dependent)
4033 : TypeDependence{})),
4034 Decl(const_cast<TypedefNameDecl *>(D)) {
4035 if ((TypedefBits.hasQualifier = !!Qualifier))
4036 *getTrailingObjects<NestedNameSpecifier>() = Qualifier;
4037 if ((TypedefBits.hasTypeDifferentFromDecl = HasTypeDifferentFromDecl))
4038 *getTrailingObjects<QualType>() = UnderlyingType;
4039}
4040
4042 return typeMatchesDecl() ? Decl->getUnderlyingType()
4043 : *getTrailingObjects<QualType>();
4044}
4045
4046UnresolvedUsingType::UnresolvedUsingType(ElaboratedTypeKeyword Keyword,
4047 NestedNameSpecifier Qualifier,
4049 const Type *CanonicalType)
4051 Keyword, UnresolvedUsing, QualType(CanonicalType, 0),
4052 TypeDependence::DependentInstantiation |
4053 (Qualifier
4054 ? toTypeDependence(Qualifier.getDependence() &
4055 ~NestedNameSpecifierDependence::Dependent)
4056 : TypeDependence{})),
4057 Decl(const_cast<UnresolvedUsingTypenameDecl *>(D)) {
4058 if ((UnresolvedUsingBits.hasQualifier = !!Qualifier))
4059 *getTrailingObjects<NestedNameSpecifier>() = Qualifier;
4060}
4061
4062UsingType::UsingType(ElaboratedTypeKeyword Keyword,
4063 NestedNameSpecifier Qualifier, const UsingShadowDecl *D,
4064 QualType UnderlyingType)
4065 : TypeWithKeyword(Keyword, Using, UnderlyingType.getCanonicalType(),
4066 toSemanticDependence(UnderlyingType->getDependence())),
4067 D(const_cast<UsingShadowDecl *>(D)), UnderlyingType(UnderlyingType) {
4068 if ((UsingBits.hasQualifier = !!Qualifier))
4069 *getTrailingObjects() = Qualifier;
4070}
4071
4073
4075 // Step over MacroQualifiedTypes from the same macro to find the type
4076 // ultimately qualified by the macro qualifier.
4077 QualType Inner = cast<AttributedType>(getUnderlyingType())->getModifiedType();
4078 while (auto *InnerMQT = dyn_cast<MacroQualifiedType>(Inner)) {
4079 if (InnerMQT->getMacroIdentifier() != getMacroIdentifier())
4080 break;
4081 Inner = InnerMQT->getModifiedType();
4082 }
4083 return Inner;
4084}
4085
4087 TypeOfKind Kind, QualType Can)
4088 : Type(TypeOfExpr,
4089 // We have to protect against 'Can' being invalid through its
4090 // default argument.
4091 Kind == TypeOfKind::Unqualified && !Can.isNull()
4092 ? Context.getUnqualifiedArrayType(Can).getAtomicUnqualifiedType()
4093 : Can,
4095 (E->getType()->getDependence() &
4096 TypeDependence::VariablyModified)),
4097 TOExpr(E), Context(Context) {
4098 TypeOfBits.Kind = static_cast<unsigned>(Kind);
4099}
4100
4101bool TypeOfExprType::isSugared() const { return !TOExpr->isTypeDependent(); }
4102
4104 if (isSugared()) {
4107 ? Context.getUnqualifiedArrayType(QT).getAtomicUnqualifiedType()
4108 : QT;
4109 }
4110 return QualType(this, 0);
4111}
4112
4113void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID,
4114 const ASTContext &Context, Expr *E,
4115 bool IsUnqual) {
4116 E->Profile(ID, Context, true);
4117 ID.AddBoolean(IsUnqual);
4118}
4119
4120TypeOfType::TypeOfType(const ASTContext &Context, QualType T, QualType Can,
4121 TypeOfKind Kind)
4122 : Type(TypeOf,
4123 Kind == TypeOfKind::Unqualified
4124 ? Context.getUnqualifiedArrayType(Can).getAtomicUnqualifiedType()
4125 : Can,
4126 T->getDependence()),
4127 TOType(T), Context(Context) {
4128 TypeOfBits.Kind = static_cast<unsigned>(Kind);
4129}
4130
4131QualType TypeOfType::desugar() const {
4132 QualType QT = getUnmodifiedType();
4134 ? Context.getUnqualifiedArrayType(QT).getAtomicUnqualifiedType()
4135 : QT;
4136}
4137
4138DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can)
4139 // C++11 [temp.type]p2: "If an expression e involves a template parameter,
4140 // decltype(e) denotes a unique dependent type." Hence a decltype type is
4141 // type-dependent even if its expression is only instantiation-dependent.
4142 : Type(Decltype, can,
4143 toTypeDependence(E->getDependence()) |
4144 (E->isInstantiationDependent() ? TypeDependence::Dependent
4145 : TypeDependence::None) |
4146 (E->getType()->getDependence() &
4147 TypeDependence::VariablyModified)),
4148 E(E), UnderlyingType(underlyingType) {}
4149
4150bool DecltypeType::isSugared() const { return !E->isInstantiationDependent(); }
4151
4152QualType DecltypeType::desugar() const {
4153 if (isSugared())
4154 return getUnderlyingType();
4155
4156 return QualType(this, 0);
4157}
4158
4159DependentDecltypeType::DependentDecltypeType(Expr *E)
4160 : DecltypeType(E, QualType()) {}
4161
4162void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
4163 const ASTContext &Context, Expr *E) {
4164 E->Profile(ID, Context, true);
4165}
4166
4167PackIndexingType::PackIndexingType(QualType Canonical, QualType Pattern,
4168 Expr *IndexExpr, bool FullySubstituted,
4169 ArrayRef<QualType> Expansions)
4170 : Type(PackIndexing, Canonical,
4171 computeDependence(Pattern, IndexExpr, Expansions)),
4172 Pattern(Pattern), IndexExpr(IndexExpr), Size(Expansions.size()),
4173 FullySubstituted(FullySubstituted) {
4174
4175 llvm::uninitialized_copy(Expansions, getTrailingObjects());
4176}
4177
4178UnsignedOrNone PackIndexingType::getSelectedIndex() const {
4179 if (isInstantiationDependentType())
4180 return std::nullopt;
4181 // Should only be not a constant for error recovery.
4182 ConstantExpr *CE = dyn_cast<ConstantExpr>(getIndexExpr());
4183 if (!CE)
4184 return std::nullopt;
4185 auto Index = CE->getResultAsAPSInt();
4186 assert(Index.isNonNegative() && "Invalid index");
4187 return static_cast<unsigned>(Index.getExtValue());
4188}
4189
4191PackIndexingType::computeDependence(QualType Pattern, Expr *IndexExpr,
4192 ArrayRef<QualType> Expansions) {
4193 TypeDependence IndexD = toTypeDependence(IndexExpr->getDependence());
4194
4195 TypeDependence TD = IndexD | (IndexExpr->isInstantiationDependent()
4196 ? TypeDependence::DependentInstantiation
4197 : TypeDependence::None);
4198 if (Expansions.empty())
4199 TD |= Pattern->getDependence() & TypeDependence::DependentInstantiation;
4200 else
4201 for (const QualType &T : Expansions)
4202 TD |= T->getDependence();
4203
4204 if (!(IndexD & TypeDependence::UnexpandedPack))
4205 TD &= ~TypeDependence::UnexpandedPack;
4206
4207 // If the pattern does not contain an unexpended pack,
4208 // the type is still dependent, and invalid
4209 if (!Pattern->containsUnexpandedParameterPack())
4210 TD |= TypeDependence::Error | TypeDependence::DependentInstantiation;
4211
4212 return TD;
4213}
4214
4215void PackIndexingType::Profile(llvm::FoldingSetNodeID &ID,
4216 const ASTContext &Context) {
4217 Profile(ID, Context, getPattern(), getIndexExpr(), isFullySubstituted(),
4218 getExpansions());
4219}
4220
4221void PackIndexingType::Profile(llvm::FoldingSetNodeID &ID,
4222 const ASTContext &Context, QualType Pattern,
4223 Expr *E, bool FullySubstituted,
4224 ArrayRef<QualType> Expansions) {
4225
4226 E->Profile(ID, Context, true);
4227 ID.AddBoolean(FullySubstituted);
4228 if (!Expansions.empty()) {
4229 ID.AddInteger(Expansions.size());
4230 for (QualType T : Expansions)
4231 T.getCanonicalType().Profile(ID);
4232 } else {
4233 Pattern.Profile(ID);
4234 }
4235}
4236
4237UnaryTransformType::UnaryTransformType(QualType BaseType,
4238 QualType UnderlyingType, UTTKind UKind,
4239 QualType CanonicalType)
4240 : Type(UnaryTransform, CanonicalType, BaseType->getDependence()),
4241 BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) {}
4242
4243TagType::TagType(TypeClass TC, ElaboratedTypeKeyword Keyword,
4244 NestedNameSpecifier Qualifier, const TagDecl *Tag,
4245 bool OwnsTag, bool ISInjected, const Type *CanonicalType)
4247 Keyword, TC, QualType(CanonicalType, 0),
4248 (Tag->isDependentType() ? TypeDependence::DependentInstantiation
4249 : TypeDependence::None) |
4250 (Qualifier
4251 ? toTypeDependence(Qualifier.getDependence() &
4252 ~NestedNameSpecifierDependence::Dependent)
4253 : TypeDependence{})),
4254 decl(const_cast<TagDecl *>(Tag)) {
4255 if ((TagTypeBits.HasQualifier = !!Qualifier))
4256 getTrailingQualifier() = Qualifier;
4257 TagTypeBits.OwnsTag = !!OwnsTag;
4258 TagTypeBits.IsInjected = ISInjected;
4259}
4260
4261void *TagType::getTrailingPointer() const {
4262 switch (getTypeClass()) {
4263 case Type::Enum:
4264 return const_cast<EnumType *>(cast<EnumType>(this) + 1);
4265 case Type::Record:
4266 return const_cast<RecordType *>(cast<RecordType>(this) + 1);
4267 case Type::InjectedClassName:
4268 return const_cast<InjectedClassNameType *>(
4269 cast<InjectedClassNameType>(this) + 1);
4270 default:
4271 llvm_unreachable("unexpected type class");
4272 }
4273}
4274
4275NestedNameSpecifier &TagType::getTrailingQualifier() const {
4276 assert(TagTypeBits.HasQualifier);
4277 return *reinterpret_cast<NestedNameSpecifier *>(llvm::alignAddr(
4278 getTrailingPointer(), llvm::Align::Of<NestedNameSpecifier *>()));
4279}
4280
4281NestedNameSpecifier TagType::getQualifier() const {
4282 return TagTypeBits.HasQualifier ? getTrailingQualifier() : std::nullopt;
4283}
4284
4285ClassTemplateDecl *TagType::getTemplateDecl() const {
4286 auto *Decl = dyn_cast<CXXRecordDecl>(decl);
4287 if (!Decl)
4288 return nullptr;
4289 if (auto *RD = dyn_cast<ClassTemplateSpecializationDecl>(Decl))
4290 return RD->getSpecializedTemplate();
4291 return Decl->getDescribedClassTemplate();
4292}
4293
4294TemplateName TagType::getTemplateName(const ASTContext &Ctx) const {
4295 auto *TD = getTemplateDecl();
4296 if (!TD)
4297 return TemplateName();
4298 if (isCanonicalUnqualified())
4299 return TemplateName(TD);
4300 return Ctx.getQualifiedTemplateName(getQualifier(), /*TemplateKeyword=*/false,
4301 TemplateName(TD));
4302}
4303
4305TagType::getTemplateArgs(const ASTContext &Ctx) const {
4306 auto *Decl = dyn_cast<CXXRecordDecl>(decl);
4307 if (!Decl)
4308 return {};
4309
4310 if (auto *RD = dyn_cast<ClassTemplateSpecializationDecl>(Decl))
4311 return RD->getTemplateArgs().asArray();
4312 if (ClassTemplateDecl *TD = Decl->getDescribedClassTemplate())
4313 return TD->getTemplateParameters()->getInjectedTemplateArgs(Ctx);
4314 return {};
4315}
4316
4317bool RecordType::hasConstFields() const {
4318 std::vector<const RecordType *> RecordTypeList;
4319 RecordTypeList.push_back(this);
4320 unsigned NextToCheckIndex = 0;
4321
4322 while (RecordTypeList.size() > NextToCheckIndex) {
4323 for (FieldDecl *FD : RecordTypeList[NextToCheckIndex]
4324 ->getOriginalDecl()
4326 ->fields()) {
4327 QualType FieldTy = FD->getType();
4328 if (FieldTy.isConstQualified())
4329 return true;
4330 FieldTy = FieldTy.getCanonicalType();
4331 if (const auto *FieldRecTy = FieldTy->getAsCanonical<RecordType>()) {
4332 if (!llvm::is_contained(RecordTypeList, FieldRecTy))
4333 RecordTypeList.push_back(FieldRecTy);
4334 }
4335 }
4336 ++NextToCheckIndex;
4337 }
4338 return false;
4339}
4340
4341InjectedClassNameType::InjectedClassNameType(ElaboratedTypeKeyword Keyword,
4342 NestedNameSpecifier Qualifier,
4343 const TagDecl *TD, bool IsInjected,
4344 const Type *CanonicalType)
4345 : TagType(TypeClass::InjectedClassName, Keyword, Qualifier, TD,
4346 /*OwnsTag=*/false, IsInjected, CanonicalType) {}
4347
4348AttributedType::AttributedType(QualType canon, const Attr *attr,
4349 QualType modified, QualType equivalent)
4350 : AttributedType(canon, attr->getKind(), attr, modified, equivalent) {}
4351
4352AttributedType::AttributedType(QualType canon, attr::Kind attrKind,
4353 const Attr *attr, QualType modified,
4354 QualType equivalent)
4355 : Type(Attributed, canon, equivalent->getDependence()), Attribute(attr),
4356 ModifiedType(modified), EquivalentType(equivalent) {
4357 AttributedTypeBits.AttrKind = attrKind;
4358 assert(!attr || attr->getKind() == attrKind);
4359}
4360
4361bool AttributedType::isQualifier() const {
4362 // FIXME: Generate this with TableGen.
4363 switch (getAttrKind()) {
4364 // These are type qualifiers in the traditional C sense: they annotate
4365 // something about a specific value/variable of a type. (They aren't
4366 // always part of the canonical type, though.)
4367 case attr::ObjCGC:
4368 case attr::ObjCOwnership:
4369 case attr::ObjCInertUnsafeUnretained:
4370 case attr::TypeNonNull:
4371 case attr::TypeNullable:
4372 case attr::TypeNullableResult:
4373 case attr::TypeNullUnspecified:
4374 case attr::LifetimeBound:
4375 case attr::AddressSpace:
4376 return true;
4377
4378 // All other type attributes aren't qualifiers; they rewrite the modified
4379 // type to be a semantically different type.
4380 default:
4381 return false;
4382 }
4383}
4384
4385bool AttributedType::isMSTypeSpec() const {
4386 // FIXME: Generate this with TableGen?
4387 switch (getAttrKind()) {
4388 default:
4389 return false;
4390 case attr::Ptr32:
4391 case attr::Ptr64:
4392 case attr::SPtr:
4393 case attr::UPtr:
4394 return true;
4395 }
4396 llvm_unreachable("invalid attr kind");
4397}
4398
4399bool AttributedType::isWebAssemblyFuncrefSpec() const {
4400 return getAttrKind() == attr::WebAssemblyFuncref;
4401}
4402
4403bool AttributedType::isCallingConv() const {
4404 // FIXME: Generate this with TableGen.
4405 switch (getAttrKind()) {
4406 default:
4407 return false;
4408 case attr::Pcs:
4409 case attr::CDecl:
4410 case attr::FastCall:
4411 case attr::StdCall:
4412 case attr::ThisCall:
4413 case attr::RegCall:
4414 case attr::SwiftCall:
4415 case attr::SwiftAsyncCall:
4416 case attr::VectorCall:
4417 case attr::AArch64VectorPcs:
4418 case attr::AArch64SVEPcs:
4419 case attr::DeviceKernel:
4420 case attr::Pascal:
4421 case attr::MSABI:
4422 case attr::SysVABI:
4423 case attr::IntelOclBicc:
4424 case attr::PreserveMost:
4425 case attr::PreserveAll:
4426 case attr::M68kRTD:
4427 case attr::PreserveNone:
4428 case attr::RISCVVectorCC:
4429 case attr::RISCVVLSCC:
4430 return true;
4431 }
4432 llvm_unreachable("invalid attr kind");
4433}
4434
4435IdentifierInfo *TemplateTypeParmType::getIdentifier() const {
4436 return isCanonicalUnqualified() ? nullptr : getDecl()->getIdentifier();
4437}
4438
4440 unsigned Index) {
4441 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D))
4442 return TTP;
4444 getReplacedTemplateParameterList(D)->getParam(Index));
4445}
4446
4447SubstTemplateTypeParmType::SubstTemplateTypeParmType(QualType Replacement,
4448 Decl *AssociatedDecl,
4449 unsigned Index,
4450 UnsignedOrNone PackIndex,
4451 bool Final)
4452 : Type(SubstTemplateTypeParm, Replacement.getCanonicalType(),
4453 Replacement->getDependence()),
4454 AssociatedDecl(AssociatedDecl) {
4455 SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType =
4456 Replacement != getCanonicalTypeInternal();
4457 if (SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType)
4458 *getTrailingObjects() = Replacement;
4459
4460 SubstTemplateTypeParmTypeBits.Index = Index;
4461 SubstTemplateTypeParmTypeBits.Final = Final;
4462 SubstTemplateTypeParmTypeBits.PackIndex =
4463 PackIndex.toInternalRepresentation();
4464 assert(AssociatedDecl != nullptr);
4465}
4466
4468SubstTemplateTypeParmType::getReplacedParameter() const {
4469 return ::getReplacedParameter(getAssociatedDecl(), getIndex());
4470}
4471
4472void SubstTemplateTypeParmType::Profile(llvm::FoldingSetNodeID &ID,
4473 QualType Replacement,
4474 const Decl *AssociatedDecl,
4475 unsigned Index,
4476 UnsignedOrNone PackIndex, bool Final) {
4477 Replacement.Profile(ID);
4478 ID.AddPointer(AssociatedDecl);
4479 ID.AddInteger(Index);
4480 ID.AddInteger(PackIndex.toInternalRepresentation());
4481 ID.AddBoolean(Final);
4482}
4483
4484SubstPackType::SubstPackType(TypeClass Derived, QualType Canon,
4485 const TemplateArgument &ArgPack)
4486 : Type(Derived, Canon,
4487 TypeDependence::DependentInstantiation |
4488 TypeDependence::UnexpandedPack),
4489 Arguments(ArgPack.pack_begin()) {
4490 assert(llvm::all_of(
4491 ArgPack.pack_elements(),
4492 [](auto &P) { return P.getKind() == TemplateArgument::Type; }) &&
4493 "non-type argument to SubstPackType?");
4494 SubstPackTypeBits.NumArgs = ArgPack.pack_size();
4495}
4496
4497TemplateArgument SubstPackType::getArgumentPack() const {
4498 return TemplateArgument(llvm::ArrayRef(Arguments, getNumArgs()));
4499}
4500
4501void SubstPackType::Profile(llvm::FoldingSetNodeID &ID) {
4502 Profile(ID, getArgumentPack());
4503}
4504
4505void SubstPackType::Profile(llvm::FoldingSetNodeID &ID,
4506 const TemplateArgument &ArgPack) {
4507 ID.AddInteger(ArgPack.pack_size());
4508 for (const auto &P : ArgPack.pack_elements())
4509 ID.AddPointer(P.getAsType().getAsOpaquePtr());
4510}
4511
4512SubstTemplateTypeParmPackType::SubstTemplateTypeParmPackType(
4513 QualType Canon, Decl *AssociatedDecl, unsigned Index, bool Final,
4514 const TemplateArgument &ArgPack)
4515 : SubstPackType(SubstTemplateTypeParmPack, Canon, ArgPack),
4516 AssociatedDeclAndFinal(AssociatedDecl, Final) {
4517 assert(AssociatedDecl != nullptr);
4518
4519 SubstPackTypeBits.SubstTemplTypeParmPackIndex = Index;
4520 assert(getNumArgs() == ArgPack.pack_size() &&
4521 "Parent bitfields in SubstPackType were overwritten."
4522 "Check NumSubstPackTypeBits.");
4523}
4524
4525Decl *SubstTemplateTypeParmPackType::getAssociatedDecl() const {
4526 return AssociatedDeclAndFinal.getPointer();
4527}
4528
4529bool SubstTemplateTypeParmPackType::getFinal() const {
4530 return AssociatedDeclAndFinal.getInt();
4531}
4532
4534SubstTemplateTypeParmPackType::getReplacedParameter() const {
4535 return ::getReplacedParameter(getAssociatedDecl(), getIndex());
4536}
4537
4538IdentifierInfo *SubstTemplateTypeParmPackType::getIdentifier() const {
4540}
4541
4542void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
4543 Profile(ID, getAssociatedDecl(), getIndex(), getFinal(), getArgumentPack());
4544}
4545
4546void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
4547 const Decl *AssociatedDecl,
4548 unsigned Index, bool Final,
4549 const TemplateArgument &ArgPack) {
4550 ID.AddPointer(AssociatedDecl);
4551 ID.AddInteger(Index);
4552 ID.AddBoolean(Final);
4553 SubstPackType::Profile(ID, ArgPack);
4554}
4555
4556SubstBuiltinTemplatePackType::SubstBuiltinTemplatePackType(
4557 QualType Canon, const TemplateArgument &ArgPack)
4558 : SubstPackType(SubstBuiltinTemplatePack, Canon, ArgPack) {}
4559
4560bool TemplateSpecializationType::anyDependentTemplateArguments(
4561 const TemplateArgumentListInfo &Args,
4562 ArrayRef<TemplateArgument> Converted) {
4563 return anyDependentTemplateArguments(Args.arguments(), Converted);
4564}
4565
4566bool TemplateSpecializationType::anyDependentTemplateArguments(
4568 for (const TemplateArgument &Arg : Converted)
4569 if (Arg.isDependent())
4570 return true;
4571 return false;
4572}
4573
4574bool TemplateSpecializationType::anyInstantiationDependentTemplateArguments(
4576 for (const TemplateArgumentLoc &ArgLoc : Args) {
4577 if (ArgLoc.getArgument().isInstantiationDependent())
4578 return true;
4579 }
4580 return false;
4581}
4582
4583static TypeDependence
4585 TypeDependence D = Underlying.isNull()
4586 ? TypeDependence::DependentInstantiation
4587 : toSemanticDependence(Underlying->getDependence());
4588 D |= toTypeDependence(T.getDependence()) & TypeDependence::UnexpandedPack;
4590 if (Underlying.isNull()) // Dependent, will produce a pack on substitution.
4591 D |= TypeDependence::UnexpandedPack;
4592 else
4593 D |= (Underlying->getDependence() & TypeDependence::UnexpandedPack);
4594 }
4595 return D;
4596}
4597
4598TemplateSpecializationType::TemplateSpecializationType(
4600 ArrayRef<TemplateArgument> Args, QualType Underlying)
4602 Underlying.isNull() ? QualType(this, 0)
4603 : Underlying.getCanonicalType(),
4605 Template(T) {
4606 TemplateSpecializationTypeBits.NumArgs = Args.size();
4607 TemplateSpecializationTypeBits.TypeAlias = IsAlias;
4608
4609 auto *TemplateArgs =
4610 const_cast<TemplateArgument *>(template_arguments().data());
4611 for (const TemplateArgument &Arg : Args) {
4612 // Update instantiation-dependent, variably-modified, and error bits.
4613 // If the canonical type exists and is non-dependent, the template
4614 // specialization type can be non-dependent even if one of the type
4615 // arguments is. Given:
4616 // template<typename T> using U = int;
4617 // U<T> is always non-dependent, irrespective of the type T.
4618 // However, U<Ts> contains an unexpanded parameter pack, even though
4619 // its expansion (and thus its desugared type) doesn't.
4620 addDependence(toTypeDependence(Arg.getDependence()) &
4621 ~TypeDependence::Dependent);
4622 if (Arg.getKind() == TemplateArgument::Type)
4623 addDependence(Arg.getAsType()->getDependence() &
4624 TypeDependence::VariablyModified);
4625 new (TemplateArgs++) TemplateArgument(Arg);
4626 }
4627
4628 // Store the aliased type after the template arguments, if this is a type
4629 // alias template specialization.
4630 if (IsAlias)
4631 *reinterpret_cast<QualType *>(TemplateArgs) = Underlying;
4632}
4633
4634QualType TemplateSpecializationType::getAliasedType() const {
4635 assert(isTypeAlias() && "not a type alias template specialization");
4636 return *reinterpret_cast<const QualType *>(template_arguments().end());
4637}
4638
4639bool clang::TemplateSpecializationType::isSugared() const {
4640 return !isDependentType() || isCurrentInstantiation() || isTypeAlias() ||
4642 isa<SubstBuiltinTemplatePackType>(*getCanonicalTypeInternal()));
4643}
4644
4645void TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
4646 const ASTContext &Ctx) {
4647 Profile(ID, getKeyword(), Template, template_arguments(),
4648 isSugared() ? desugar() : QualType(), Ctx);
4649}
4650
4651void TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
4655 QualType Underlying,
4656 const ASTContext &Context) {
4657 ID.AddInteger(llvm::to_underlying(Keyword));
4658 T.Profile(ID);
4659 Underlying.Profile(ID);
4660
4661 ID.AddInteger(Args.size());
4662 for (const TemplateArgument &Arg : Args)
4663 Arg.Profile(ID, Context);
4664}
4665
4667 QualType QT) const {
4668 if (!hasNonFastQualifiers())
4670
4671 return Context.getQualifiedType(QT, *this);
4672}
4673
4675 const Type *T) const {
4676 if (!hasNonFastQualifiers())
4677 return QualType(T, getFastQualifiers());
4678
4679 return Context.getQualifiedType(T, *this);
4680}
4681
4682void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
4683 ArrayRef<QualType> typeArgs,
4685 bool isKindOf) {
4686 ID.AddPointer(BaseType.getAsOpaquePtr());
4687 ID.AddInteger(typeArgs.size());
4688 for (auto typeArg : typeArgs)
4689 ID.AddPointer(typeArg.getAsOpaquePtr());
4690 ID.AddInteger(protocols.size());
4691 for (auto *proto : protocols)
4692 ID.AddPointer(proto);
4693 ID.AddBoolean(isKindOf);
4694}
4695
4696void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) {
4697 Profile(ID, getBaseType(), getTypeArgsAsWritten(),
4698 llvm::ArrayRef(qual_begin(), getNumProtocols()),
4699 isKindOfTypeAsWritten());
4700}
4701
4702void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID,
4703 const ObjCTypeParamDecl *OTPDecl,
4704 QualType CanonicalType,
4705 ArrayRef<ObjCProtocolDecl *> protocols) {
4706 ID.AddPointer(OTPDecl);
4707 ID.AddPointer(CanonicalType.getAsOpaquePtr());
4708 ID.AddInteger(protocols.size());
4709 for (auto *proto : protocols)
4710 ID.AddPointer(proto);
4711}
4712
4713void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID) {
4714 Profile(ID, getDecl(), getCanonicalTypeInternal(),
4715 llvm::ArrayRef(qual_begin(), getNumProtocols()));
4716}
4717
4718namespace {
4719
4720/// The cached properties of a type.
4721class CachedProperties {
4722 Linkage L;
4723 bool local;
4724
4725public:
4726 CachedProperties(Linkage L, bool local) : L(L), local(local) {}
4727
4728 Linkage getLinkage() const { return L; }
4729 bool hasLocalOrUnnamedType() const { return local; }
4730
4731 friend CachedProperties merge(CachedProperties L, CachedProperties R) {
4732 Linkage MergedLinkage = minLinkage(L.L, R.L);
4733 return CachedProperties(MergedLinkage, L.hasLocalOrUnnamedType() ||
4734 R.hasLocalOrUnnamedType());
4735 }
4736};
4737
4738} // namespace
4739
4740static CachedProperties computeCachedProperties(const Type *T);
4741
4742namespace clang {
4743
4744/// The type-property cache. This is templated so as to be
4745/// instantiated at an internal type to prevent unnecessary symbol
4746/// leakage.
4747template <class Private> class TypePropertyCache {
4748public:
4749 static CachedProperties get(QualType T) { return get(T.getTypePtr()); }
4750
4751 static CachedProperties get(const Type *T) {
4752 ensure(T);
4753 return CachedProperties(T->TypeBits.getLinkage(),
4754 T->TypeBits.hasLocalOrUnnamedType());
4755 }
4756
4757 static void ensure(const Type *T) {
4758 // If the cache is valid, we're okay.
4759 if (T->TypeBits.isCacheValid())
4760 return;
4761
4762 // If this type is non-canonical, ask its canonical type for the
4763 // relevant information.
4764 if (!T->isCanonicalUnqualified()) {
4765 const Type *CT = T->getCanonicalTypeInternal().getTypePtr();
4766 ensure(CT);
4767 T->TypeBits.CacheValid = true;
4768 T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage;
4769 T->TypeBits.CachedLocalOrUnnamed = CT->TypeBits.CachedLocalOrUnnamed;
4770 return;
4771 }
4772
4773 // Compute the cached properties and then set the cache.
4774 CachedProperties Result = computeCachedProperties(T);
4775 T->TypeBits.CacheValid = true;
4776 T->TypeBits.CachedLinkage = llvm::to_underlying(Result.getLinkage());
4777 T->TypeBits.CachedLocalOrUnnamed = Result.hasLocalOrUnnamedType();
4778 }
4779};
4780
4781} // namespace clang
4782
4783// Instantiate the friend template at a private class. In a
4784// reasonable implementation, these symbols will be internal.
4785// It is terrible that this is the best way to accomplish this.
4786namespace {
4787
4788class Private {};
4789
4790} // namespace
4791
4793
4794static CachedProperties computeCachedProperties(const Type *T) {
4795 switch (T->getTypeClass()) {
4796#define TYPE(Class, Base)
4797#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
4798#include "clang/AST/TypeNodes.inc"
4799 llvm_unreachable("didn't expect a non-canonical type here");
4800
4801#define TYPE(Class, Base)
4802#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4803#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
4804#include "clang/AST/TypeNodes.inc"
4805 // Treat instantiation-dependent types as external.
4806 assert(T->isInstantiationDependentType());
4807 return CachedProperties(Linkage::External, false);
4808
4809 case Type::Auto:
4810 case Type::DeducedTemplateSpecialization:
4811 // Give non-deduced 'auto' types external linkage. We should only see them
4812 // here in error recovery.
4813 return CachedProperties(Linkage::External, false);
4814
4815 case Type::BitInt:
4816 case Type::Builtin:
4817 // C++ [basic.link]p8:
4818 // A type is said to have linkage if and only if:
4819 // - it is a fundamental type (3.9.1); or
4820 return CachedProperties(Linkage::External, false);
4821
4822 case Type::Record:
4823 case Type::Enum: {
4824 const TagDecl *Tag =
4825 cast<TagType>(T)->getOriginalDecl()->getDefinitionOrSelf();
4826
4827 // C++ [basic.link]p8:
4828 // - it is a class or enumeration type that is named (or has a name
4829 // for linkage purposes (7.1.3)) and the name has linkage; or
4830 // - it is a specialization of a class template (14); or
4831 Linkage L = Tag->getLinkageInternal();
4832 bool IsLocalOrUnnamed = Tag->getDeclContext()->isFunctionOrMethod() ||
4833 !Tag->hasNameForLinkage();
4834 return CachedProperties(L, IsLocalOrUnnamed);
4835 }
4836
4837 // C++ [basic.link]p8:
4838 // - it is a compound type (3.9.2) other than a class or enumeration,
4839 // compounded exclusively from types that have linkage; or
4840 case Type::Complex:
4841 return Cache::get(cast<ComplexType>(T)->getElementType());
4842 case Type::Pointer:
4844 case Type::BlockPointer:
4846 case Type::LValueReference:
4847 case Type::RValueReference:
4849 case Type::MemberPointer: {
4850 const auto *MPT = cast<MemberPointerType>(T);
4851 CachedProperties Cls = [&] {
4852 if (MPT->isSugared())
4853 MPT = cast<MemberPointerType>(MPT->getCanonicalTypeInternal());
4854 return Cache::get(MPT->getQualifier().getAsType());
4855 }();
4856 return merge(Cls, Cache::get(MPT->getPointeeType()));
4857 }
4858 case Type::ConstantArray:
4859 case Type::IncompleteArray:
4860 case Type::VariableArray:
4861 case Type::ArrayParameter:
4862 return Cache::get(cast<ArrayType>(T)->getElementType());
4863 case Type::Vector:
4864 case Type::ExtVector:
4865 return Cache::get(cast<VectorType>(T)->getElementType());
4866 case Type::ConstantMatrix:
4867 return Cache::get(cast<ConstantMatrixType>(T)->getElementType());
4868 case Type::FunctionNoProto:
4869 return Cache::get(cast<FunctionType>(T)->getReturnType());
4870 case Type::FunctionProto: {
4871 const auto *FPT = cast<FunctionProtoType>(T);
4872 CachedProperties result = Cache::get(FPT->getReturnType());
4873 for (const auto &ai : FPT->param_types())
4874 result = merge(result, Cache::get(ai));
4875 return result;
4876 }
4877 case Type::ObjCInterface: {
4878 Linkage L = cast<ObjCInterfaceType>(T)->getDecl()->getLinkageInternal();
4879 return CachedProperties(L, false);
4880 }
4881 case Type::ObjCObject:
4882 return Cache::get(cast<ObjCObjectType>(T)->getBaseType());
4883 case Type::ObjCObjectPointer:
4885 case Type::Atomic:
4886 return Cache::get(cast<AtomicType>(T)->getValueType());
4887 case Type::Pipe:
4888 return Cache::get(cast<PipeType>(T)->getElementType());
4889 case Type::HLSLAttributedResource:
4890 return Cache::get(cast<HLSLAttributedResourceType>(T)->getWrappedType());
4891 case Type::HLSLInlineSpirv:
4892 return CachedProperties(Linkage::External, false);
4893 }
4894
4895 llvm_unreachable("unhandled type class");
4896}
4897
4898/// Determine the linkage of this type.
4900 Cache::ensure(this);
4901 return TypeBits.getLinkage();
4902}
4903
4905 Cache::ensure(this);
4906 return TypeBits.hasLocalOrUnnamedType();
4907}
4908
4910 switch (T->getTypeClass()) {
4911#define TYPE(Class, Base)
4912#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
4913#include "clang/AST/TypeNodes.inc"
4914 llvm_unreachable("didn't expect a non-canonical type here");
4915
4916#define TYPE(Class, Base)
4917#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4918#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
4919#include "clang/AST/TypeNodes.inc"
4920 // Treat instantiation-dependent types as external.
4921 assert(T->isInstantiationDependentType());
4922 return LinkageInfo::external();
4923
4924 case Type::BitInt:
4925 case Type::Builtin:
4926 return LinkageInfo::external();
4927
4928 case Type::Auto:
4929 case Type::DeducedTemplateSpecialization:
4930 return LinkageInfo::external();
4931
4932 case Type::Record:
4933 case Type::Enum:
4935 cast<TagType>(T)->getOriginalDecl()->getDefinitionOrSelf());
4936
4937 case Type::Complex:
4938 return computeTypeLinkageInfo(cast<ComplexType>(T)->getElementType());
4939 case Type::Pointer:
4941 case Type::BlockPointer:
4943 case Type::LValueReference:
4944 case Type::RValueReference:
4946 case Type::MemberPointer: {
4947 const auto *MPT = cast<MemberPointerType>(T);
4948 LinkageInfo LV;
4949 if (auto *D = MPT->getMostRecentCXXRecordDecl()) {
4951 } else {
4952 LV.merge(computeTypeLinkageInfo(MPT->getQualifier().getAsType()));
4953 }
4954 LV.merge(computeTypeLinkageInfo(MPT->getPointeeType()));
4955 return LV;
4956 }
4957 case Type::ConstantArray:
4958 case Type::IncompleteArray:
4959 case Type::VariableArray:
4960 case Type::ArrayParameter:
4961 return computeTypeLinkageInfo(cast<ArrayType>(T)->getElementType());
4962 case Type::Vector:
4963 case Type::ExtVector:
4964 return computeTypeLinkageInfo(cast<VectorType>(T)->getElementType());
4965 case Type::ConstantMatrix:
4967 cast<ConstantMatrixType>(T)->getElementType());
4968 case Type::FunctionNoProto:
4969 return computeTypeLinkageInfo(cast<FunctionType>(T)->getReturnType());
4970 case Type::FunctionProto: {
4971 const auto *FPT = cast<FunctionProtoType>(T);
4972 LinkageInfo LV = computeTypeLinkageInfo(FPT->getReturnType());
4973 for (const auto &ai : FPT->param_types())
4975 return LV;
4976 }
4977 case Type::ObjCInterface:
4979 case Type::ObjCObject:
4980 return computeTypeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
4981 case Type::ObjCObjectPointer:
4984 case Type::Atomic:
4985 return computeTypeLinkageInfo(cast<AtomicType>(T)->getValueType());
4986 case Type::Pipe:
4987 return computeTypeLinkageInfo(cast<PipeType>(T)->getElementType());
4988 case Type::HLSLAttributedResource:
4990 ->getContainedType()
4991 ->getCanonicalTypeInternal());
4992 case Type::HLSLInlineSpirv:
4993 return LinkageInfo::external();
4994 }
4995
4996 llvm_unreachable("unhandled type class");
4997}
4998
5000 if (!TypeBits.isCacheValid())
5001 return true;
5002
5005 .getLinkage();
5006 return L == TypeBits.getLinkage();
5007}
5008
5010 if (!T->isCanonicalUnqualified())
5011 return computeTypeLinkageInfo(T->getCanonicalTypeInternal());
5012
5014 assert(LV.getLinkage() == T->getLinkage());
5015 return LV;
5016}
5017
5021
5022std::optional<NullabilityKind> Type::getNullability() const {
5023 QualType Type(this, 0);
5024 while (const auto *AT = Type->getAs<AttributedType>()) {
5025 // Check whether this is an attributed type with nullability
5026 // information.
5027 if (auto Nullability = AT->getImmediateNullability())
5028 return Nullability;
5029
5030 Type = AT->getEquivalentType();
5031 }
5032 return std::nullopt;
5033}
5034
5035bool Type::canHaveNullability(bool ResultIfUnknown) const {
5037
5038 switch (type->getTypeClass()) {
5039#define NON_CANONICAL_TYPE(Class, Parent) \
5040 /* We'll only see canonical types here. */ \
5041 case Type::Class: \
5042 llvm_unreachable("non-canonical type");
5043#define TYPE(Class, Parent)
5044#include "clang/AST/TypeNodes.inc"
5045
5046 // Pointer types.
5047 case Type::Pointer:
5048 case Type::BlockPointer:
5049 case Type::MemberPointer:
5050 case Type::ObjCObjectPointer:
5051 return true;
5052
5053 // Dependent types that could instantiate to pointer types.
5054 case Type::UnresolvedUsing:
5055 case Type::TypeOfExpr:
5056 case Type::TypeOf:
5057 case Type::Decltype:
5058 case Type::PackIndexing:
5059 case Type::UnaryTransform:
5060 case Type::TemplateTypeParm:
5061 case Type::SubstTemplateTypeParmPack:
5062 case Type::SubstBuiltinTemplatePack:
5063 case Type::DependentName:
5064 case Type::Auto:
5065 return ResultIfUnknown;
5066
5067 // Dependent template specializations could instantiate to pointer types.
5068 case Type::TemplateSpecialization:
5069 // If it's a known class template, we can already check if it's nullable.
5070 if (TemplateDecl *templateDecl =
5072 ->getTemplateName()
5073 .getAsTemplateDecl())
5074 if (auto *CTD = dyn_cast<ClassTemplateDecl>(templateDecl))
5075 return llvm::any_of(
5076 CTD->redecls(), [](const RedeclarableTemplateDecl *RTD) {
5077 return RTD->getTemplatedDecl()->hasAttr<TypeNullableAttr>();
5078 });
5079 return ResultIfUnknown;
5080
5081 case Type::Builtin:
5082 switch (cast<BuiltinType>(type.getTypePtr())->getKind()) {
5083 // Signed, unsigned, and floating-point types cannot have nullability.
5084#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
5085#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
5086#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
5087#define BUILTIN_TYPE(Id, SingletonId)
5088#include "clang/AST/BuiltinTypes.def"
5089 return false;
5090
5091 case BuiltinType::UnresolvedTemplate:
5092 // Dependent types that could instantiate to a pointer type.
5093 case BuiltinType::Dependent:
5094 case BuiltinType::Overload:
5095 case BuiltinType::BoundMember:
5096 case BuiltinType::PseudoObject:
5097 case BuiltinType::UnknownAny:
5098 case BuiltinType::ARCUnbridgedCast:
5099 return ResultIfUnknown;
5100
5101 case BuiltinType::Void:
5102 case BuiltinType::ObjCId:
5103 case BuiltinType::ObjCClass:
5104 case BuiltinType::ObjCSel:
5105#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
5106 case BuiltinType::Id:
5107#include "clang/Basic/OpenCLImageTypes.def"
5108#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
5109#include "clang/Basic/OpenCLExtensionTypes.def"
5110 case BuiltinType::OCLSampler:
5111 case BuiltinType::OCLEvent:
5112 case BuiltinType::OCLClkEvent:
5113 case BuiltinType::OCLQueue:
5114 case BuiltinType::OCLReserveID:
5115#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
5116#include "clang/Basic/AArch64ACLETypes.def"
5117#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
5118#include "clang/Basic/PPCTypes.def"
5119#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
5120#include "clang/Basic/RISCVVTypes.def"
5121#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
5122#include "clang/Basic/WebAssemblyReferenceTypes.def"
5123#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
5124#include "clang/Basic/AMDGPUTypes.def"
5125#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
5126#include "clang/Basic/HLSLIntangibleTypes.def"
5127 case BuiltinType::BuiltinFn:
5128 case BuiltinType::NullPtr:
5129 case BuiltinType::IncompleteMatrixIdx:
5130 case BuiltinType::ArraySection:
5131 case BuiltinType::OMPArrayShaping:
5132 case BuiltinType::OMPIterator:
5133 return false;
5134 }
5135 llvm_unreachable("unknown builtin type");
5136
5137 case Type::Record: {
5138 const RecordDecl *RD = cast<RecordType>(type)->getOriginalDecl();
5139 // For template specializations, look only at primary template attributes.
5140 // This is a consistent regardless of whether the instantiation is known.
5141 if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
5142 return llvm::any_of(
5143 CTSD->getSpecializedTemplate()->redecls(),
5144 [](const RedeclarableTemplateDecl *RTD) {
5145 return RTD->getTemplatedDecl()->hasAttr<TypeNullableAttr>();
5146 });
5147 return llvm::any_of(RD->redecls(), [](const TagDecl *RD) {
5148 return RD->hasAttr<TypeNullableAttr>();
5149 });
5150 }
5151
5152 // Non-pointer types.
5153 case Type::Complex:
5154 case Type::LValueReference:
5155 case Type::RValueReference:
5156 case Type::ConstantArray:
5157 case Type::IncompleteArray:
5158 case Type::VariableArray:
5159 case Type::DependentSizedArray:
5160 case Type::DependentVector:
5161 case Type::DependentSizedExtVector:
5162 case Type::Vector:
5163 case Type::ExtVector:
5164 case Type::ConstantMatrix:
5165 case Type::DependentSizedMatrix:
5166 case Type::DependentAddressSpace:
5167 case Type::FunctionProto:
5168 case Type::FunctionNoProto:
5169 case Type::DeducedTemplateSpecialization:
5170 case Type::Enum:
5171 case Type::InjectedClassName:
5172 case Type::PackExpansion:
5173 case Type::ObjCObject:
5174 case Type::ObjCInterface:
5175 case Type::Atomic:
5176 case Type::Pipe:
5177 case Type::BitInt:
5178 case Type::DependentBitInt:
5179 case Type::ArrayParameter:
5180 case Type::HLSLAttributedResource:
5181 case Type::HLSLInlineSpirv:
5182 return false;
5183 }
5184 llvm_unreachable("bad type kind!");
5185}
5186
5187std::optional<NullabilityKind> AttributedType::getImmediateNullability() const {
5188 if (getAttrKind() == attr::TypeNonNull)
5190 if (getAttrKind() == attr::TypeNullable)
5192 if (getAttrKind() == attr::TypeNullUnspecified)
5194 if (getAttrKind() == attr::TypeNullableResult)
5196 return std::nullopt;
5197}
5198
5199std::optional<NullabilityKind>
5200AttributedType::stripOuterNullability(QualType &T) {
5201 QualType AttrTy = T;
5202 if (auto MacroTy = dyn_cast<MacroQualifiedType>(T))
5203 AttrTy = MacroTy->getUnderlyingType();
5204
5205 if (auto attributed = dyn_cast<AttributedType>(AttrTy)) {
5206 if (auto nullability = attributed->getImmediateNullability()) {
5207 T = attributed->getModifiedType();
5208 return nullability;
5209 }
5210 }
5211
5212 return std::nullopt;
5213}
5214
5216 if (!isIntegralType(Ctx) || isEnumeralType())
5217 return false;
5218 return Ctx.getTypeSize(this) == Ctx.getTypeSize(Ctx.VoidPtrTy);
5219}
5220
5222 const auto *objcPtr = getAs<ObjCObjectPointerType>();
5223 if (!objcPtr)
5224 return false;
5225
5226 if (objcPtr->isObjCIdType()) {
5227 // id is always okay.
5228 return true;
5229 }
5230
5231 // Blocks are NSObjects.
5232 if (ObjCInterfaceDecl *iface = objcPtr->getInterfaceDecl()) {
5233 if (iface->getIdentifier() != ctx.getNSObjectName())
5234 return false;
5235
5236 // Continue to check qualifiers, below.
5237 } else if (objcPtr->isObjCQualifiedIdType()) {
5238 // Continue to check qualifiers, below.
5239 } else {
5240 return false;
5241 }
5242
5243 // Check protocol qualifiers.
5244 for (ObjCProtocolDecl *proto : objcPtr->quals()) {
5245 // Blocks conform to NSObject and NSCopying.
5246 if (proto->getIdentifier() != ctx.getNSObjectName() &&
5247 proto->getIdentifier() != ctx.getNSCopyingName())
5248 return false;
5249 }
5250
5251 return true;
5252}
5253
5259
5261 assert(isObjCLifetimeType() &&
5262 "cannot query implicit lifetime for non-inferrable type");
5263
5264 const Type *canon = getCanonicalTypeInternal().getTypePtr();
5265
5266 // Walk down to the base type. We don't care about qualifiers for this.
5267 while (const auto *array = dyn_cast<ArrayType>(canon))
5268 canon = array->getElementType().getTypePtr();
5269
5270 if (const auto *opt = dyn_cast<ObjCObjectPointerType>(canon)) {
5271 // Class and Class<Protocol> don't require retention.
5272 if (opt->getObjectType()->isObjCClass())
5273 return true;
5274 }
5275
5276 return false;
5277}
5278
5280 if (const auto *typedefType = getAs<TypedefType>())
5281 return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>();
5282 return false;
5283}
5284
5286 if (const auto *typedefType = getAs<TypedefType>())
5287 return typedefType->getDecl()->hasAttr<ObjCIndependentClassAttr>();
5288 return false;
5289}
5290
5295
5297 if (isObjCLifetimeType())
5298 return true;
5299 if (const auto *OPT = getAs<PointerType>())
5300 return OPT->getPointeeType()->isObjCIndirectLifetimeType();
5301 if (const auto *Ref = getAs<ReferenceType>())
5302 return Ref->getPointeeType()->isObjCIndirectLifetimeType();
5303 if (const auto *MemPtr = getAs<MemberPointerType>())
5304 return MemPtr->getPointeeType()->isObjCIndirectLifetimeType();
5305 return false;
5306}
5307
5308/// Returns true if objects of this type have lifetime semantics under
5309/// ARC.
5311 const Type *type = this;
5312 while (const ArrayType *array = type->getAsArrayTypeUnsafe())
5313 type = array->getElementType().getTypePtr();
5314 return type->isObjCRetainableType();
5315}
5316
5317/// Determine whether the given type T is a "bridgable" Objective-C type,
5318/// which is either an Objective-C object pointer type or an
5322
5323/// Determine whether the given type T is a "bridgeable" C type.
5325 const auto *Pointer = getAsCanonical<PointerType>();
5326 if (!Pointer)
5327 return false;
5328
5329 QualType Pointee = Pointer->getPointeeType();
5330 return Pointee->isVoidType() || Pointee->isRecordType();
5331}
5332
5333/// Check if the specified type is the CUDA device builtin surface type.
5335 if (const auto *RT = getAsCanonical<RecordType>())
5336 return RT->getOriginalDecl()
5337 ->getMostRecentDecl()
5338 ->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>();
5339 return false;
5340}
5341
5342/// Check if the specified type is the CUDA device builtin texture type.
5344 if (const auto *RT = getAsCanonical<RecordType>())
5345 return RT->getOriginalDecl()
5346 ->getMostRecentDecl()
5347 ->hasAttr<CUDADeviceBuiltinTextureTypeAttr>();
5348 return false;
5349}
5350
5353 return false;
5354
5355 if (const auto *ptr = getAs<PointerType>())
5356 return ptr->getPointeeType()->hasSizedVLAType();
5357 if (const auto *ref = getAs<ReferenceType>())
5358 return ref->getPointeeType()->hasSizedVLAType();
5359 if (const ArrayType *arr = getAsArrayTypeUnsafe()) {
5360 if (isa<VariableArrayType>(arr) &&
5361 cast<VariableArrayType>(arr)->getSizeExpr())
5362 return true;
5363
5364 return arr->getElementType()->hasSizedVLAType();
5365 }
5366
5367 return false;
5368}
5369
5371 return HLSLAttributedResourceType::findHandleTypeOnResource(this) != nullptr;
5372}
5373
5375 const Type *Ty = getUnqualifiedDesugaredType();
5376 if (!Ty->isArrayType())
5377 return false;
5378 while (isa<ArrayType>(Ty))
5380 return Ty->isHLSLResourceRecord();
5381}
5382
5384 const Type *Ty = getUnqualifiedDesugaredType();
5385
5386 // check if it's a builtin type first
5387 if (Ty->isBuiltinType())
5388 return Ty->isHLSLBuiltinIntangibleType();
5389
5390 // unwrap arrays
5391 while (isa<ArrayType>(Ty))
5393
5394 const RecordType *RT =
5395 dyn_cast<RecordType>(Ty->getUnqualifiedDesugaredType());
5396 if (!RT)
5397 return false;
5398
5399 CXXRecordDecl *RD = RT->getAsCXXRecordDecl();
5400 assert(RD != nullptr &&
5401 "all HLSL structs and classes should be CXXRecordDecl");
5402 assert(RD->isCompleteDefinition() && "expecting complete type");
5403 return RD->isHLSLIntangible();
5404}
5405
5406QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) {
5407 switch (type.getObjCLifetime()) {
5411 break;
5412
5416 return DK_objc_weak_lifetime;
5417 }
5418
5419 if (const auto *RD = type->getBaseElementTypeUnsafe()->getAsRecordDecl()) {
5420 if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
5421 /// Check if this is a C++ object with a non-trivial destructor.
5422 if (CXXRD->hasDefinition() && !CXXRD->hasTrivialDestructor())
5423 return DK_cxx_destructor;
5424 } else {
5425 /// Check if this is a C struct that is non-trivial to destroy or an array
5426 /// that contains such a struct.
5429 }
5430 }
5431
5432 return DK_none;
5433}
5434
5437 *D2 = getQualifier().getAsRecordDecl();
5438 assert(!D1 == !D2);
5439 return D1 != D2 && D1->getCanonicalDecl() != D2->getCanonicalDecl();
5440}
5441
5442void MemberPointerType::Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
5443 const NestedNameSpecifier Qualifier,
5444 const CXXRecordDecl *Cls) {
5445 ID.AddPointer(Pointee.getAsOpaquePtr());
5446 Qualifier.Profile(ID);
5447 if (Cls)
5448 ID.AddPointer(Cls->getCanonicalDecl());
5449}
5450
5451CXXRecordDecl *MemberPointerType::getCXXRecordDecl() const {
5452 return dyn_cast<MemberPointerType>(getCanonicalTypeInternal())
5453 ->getQualifier()
5454 .getAsRecordDecl();
5455}
5456
5458 auto *RD = getCXXRecordDecl();
5459 if (!RD)
5460 return nullptr;
5461 return RD->getMostRecentDecl();
5462}
5463
5465 llvm::APSInt Val, unsigned Scale) {
5466 llvm::FixedPointSemantics FXSema(Val.getBitWidth(), Scale, Val.isSigned(),
5467 /*IsSaturated=*/false,
5468 /*HasUnsignedPadding=*/false);
5469 llvm::APFixedPoint(Val, FXSema).toString(Str);
5470}
5471
5472AutoType::AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
5473 TypeDependence ExtraDependence, QualType Canon,
5474 TemplateDecl *TypeConstraintConcept,
5475 ArrayRef<TemplateArgument> TypeConstraintArgs)
5476 : DeducedType(Auto, DeducedAsType, ExtraDependence, Canon) {
5477 AutoTypeBits.Keyword = llvm::to_underlying(Keyword);
5478 AutoTypeBits.NumArgs = TypeConstraintArgs.size();
5479 this->TypeConstraintConcept = TypeConstraintConcept;
5480 assert(TypeConstraintConcept || AutoTypeBits.NumArgs == 0);
5481 if (TypeConstraintConcept) {
5482 if (isa<TemplateTemplateParmDecl>(TypeConstraintConcept))
5483 addDependence(TypeDependence::DependentInstantiation);
5484
5485 auto *ArgBuffer =
5486 const_cast<TemplateArgument *>(getTypeConstraintArguments().data());
5487 for (const TemplateArgument &Arg : TypeConstraintArgs) {
5488 // We only syntactically depend on the constraint arguments. They don't
5489 // affect the deduced type, only its validity.
5490 addDependence(
5491 toSyntacticDependence(toTypeDependence(Arg.getDependence())));
5492
5493 new (ArgBuffer++) TemplateArgument(Arg);
5494 }
5495 }
5496}
5497
5498void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
5500 bool IsDependent, TemplateDecl *CD,
5501 ArrayRef<TemplateArgument> Arguments) {
5502 ID.AddPointer(Deduced.getAsOpaquePtr());
5503 ID.AddInteger((unsigned)Keyword);
5504 ID.AddBoolean(IsDependent);
5505 ID.AddPointer(CD);
5506 for (const TemplateArgument &Arg : Arguments)
5507 Arg.Profile(ID, Context);
5508}
5509
5510void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
5511 Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(),
5512 getTypeConstraintConcept(), getTypeConstraintArguments());
5513}
5514
5516 switch (kind()) {
5517 case Kind::NonBlocking:
5518 return Kind::Blocking;
5519 case Kind::Blocking:
5520 return Kind::NonBlocking;
5522 return Kind::Allocating;
5523 case Kind::Allocating:
5524 return Kind::NonAllocating;
5525 }
5526 llvm_unreachable("unknown effect kind");
5527}
5528
5529StringRef FunctionEffect::name() const {
5530 switch (kind()) {
5531 case Kind::NonBlocking:
5532 return "nonblocking";
5534 return "nonallocating";
5535 case Kind::Blocking:
5536 return "blocking";
5537 case Kind::Allocating:
5538 return "allocating";
5539 }
5540 llvm_unreachable("unknown effect kind");
5541}
5542
5544 const Decl &Callee, FunctionEffectKindSet CalleeFX) const {
5545 switch (kind()) {
5547 case Kind::NonBlocking: {
5548 for (FunctionEffect Effect : CalleeFX) {
5549 // nonblocking/nonallocating cannot call allocating.
5550 if (Effect.kind() == Kind::Allocating)
5551 return Effect;
5552 // nonblocking cannot call blocking.
5553 if (kind() == Kind::NonBlocking && Effect.kind() == Kind::Blocking)
5554 return Effect;
5555 }
5556 return std::nullopt;
5557 }
5558
5559 case Kind::Allocating:
5560 case Kind::Blocking:
5561 assert(0 && "effectProhibitingInference with non-inferable effect kind");
5562 break;
5563 }
5564 llvm_unreachable("unknown effect kind");
5565}
5566
5568 bool Direct, FunctionEffectKindSet CalleeFX) const {
5569 switch (kind()) {
5571 case Kind::NonBlocking: {
5572 const Kind CallerKind = kind();
5573 for (FunctionEffect Effect : CalleeFX) {
5574 const Kind EK = Effect.kind();
5575 // Does callee have same or stronger constraint?
5576 if (EK == CallerKind ||
5577 (CallerKind == Kind::NonAllocating && EK == Kind::NonBlocking)) {
5578 return false; // no diagnostic
5579 }
5580 }
5581 return true; // warning
5582 }
5583 case Kind::Allocating:
5584 case Kind::Blocking:
5585 return false;
5586 }
5587 llvm_unreachable("unknown effect kind");
5588}
5589
5590// =====
5591
5593 Conflicts &Errs) {
5594 FunctionEffect::Kind NewOppositeKind = NewEC.Effect.oppositeKind();
5595 Expr *NewCondition = NewEC.Cond.getCondition();
5596
5597 // The index at which insertion will take place; default is at end
5598 // but we might find an earlier insertion point.
5599 unsigned InsertIdx = Effects.size();
5600 unsigned Idx = 0;
5601 for (const FunctionEffectWithCondition &EC : *this) {
5602 // Note about effects with conditions: They are considered distinct from
5603 // those without conditions; they are potentially unique, redundant, or
5604 // in conflict, but we can't tell which until the condition is evaluated.
5605 if (EC.Cond.getCondition() == nullptr && NewCondition == nullptr) {
5606 if (EC.Effect.kind() == NewEC.Effect.kind()) {
5607 // There is no condition, and the effect kind is already present,
5608 // so just fail to insert the new one (creating a duplicate),
5609 // and return success.
5610 return true;
5611 }
5612
5613 if (EC.Effect.kind() == NewOppositeKind) {
5614 Errs.push_back({EC, NewEC});
5615 return false;
5616 }
5617 }
5618
5619 if (NewEC.Effect.kind() < EC.Effect.kind() && InsertIdx > Idx)
5620 InsertIdx = Idx;
5621
5622 ++Idx;
5623 }
5624
5625 if (NewCondition || !Conditions.empty()) {
5626 if (Conditions.empty() && !Effects.empty())
5627 Conditions.resize(Effects.size());
5628 Conditions.insert(Conditions.begin() + InsertIdx,
5629 NewEC.Cond.getCondition());
5630 }
5631 Effects.insert(Effects.begin() + InsertIdx, NewEC.Effect);
5632 return true;
5633}
5634
5636 for (const auto &Item : Set)
5637 insert(Item, Errs);
5638 return Errs.empty();
5639}
5640
5642 FunctionEffectsRef RHS) {
5645
5646 // We could use std::set_intersection but that would require expanding the
5647 // container interface to include push_back, making it available to clients
5648 // who might fail to maintain invariants.
5649 auto IterA = LHS.begin(), EndA = LHS.end();
5650 auto IterB = RHS.begin(), EndB = RHS.end();
5651
5652 auto FEWCLess = [](const FunctionEffectWithCondition &LHS,
5653 const FunctionEffectWithCondition &RHS) {
5654 return std::tuple(LHS.Effect, uintptr_t(LHS.Cond.getCondition())) <
5655 std::tuple(RHS.Effect, uintptr_t(RHS.Cond.getCondition()));
5656 };
5657
5658 while (IterA != EndA && IterB != EndB) {
5659 FunctionEffectWithCondition A = *IterA;
5660 FunctionEffectWithCondition B = *IterB;
5661 if (FEWCLess(A, B))
5662 ++IterA;
5663 else if (FEWCLess(B, A))
5664 ++IterB;
5665 else {
5666 Result.insert(A, Errs);
5667 ++IterA;
5668 ++IterB;
5669 }
5670 }
5671
5672 // Insertion shouldn't be able to fail; that would mean both input
5673 // sets contained conflicts.
5674 assert(Errs.empty() && "conflict shouldn't be possible in getIntersection");
5675
5676 return Result;
5677}
5678
5681 Conflicts &Errs) {
5682 // Optimize for either of the two sets being empty (very common).
5683 if (LHS.empty())
5684 return FunctionEffectSet(RHS);
5685
5686 FunctionEffectSet Combined(LHS);
5687 Combined.insert(RHS, Errs);
5688 return Combined;
5689}
5690
5691namespace clang {
5692
5693raw_ostream &operator<<(raw_ostream &OS,
5694 const FunctionEffectWithCondition &CFE) {
5695 OS << CFE.Effect.name();
5696 if (Expr *E = CFE.Cond.getCondition()) {
5697 OS << '(';
5698 E->dump();
5699 OS << ')';
5700 }
5701 return OS;
5702}
5703
5704} // namespace clang
5705
5706LLVM_DUMP_METHOD void FunctionEffectsRef::dump(llvm::raw_ostream &OS) const {
5707 OS << "Effects{";
5708 llvm::interleaveComma(*this, OS);
5709 OS << "}";
5710}
5711
5712LLVM_DUMP_METHOD void FunctionEffectSet::dump(llvm::raw_ostream &OS) const {
5713 FunctionEffectsRef(*this).dump(OS);
5714}
5715
5716LLVM_DUMP_METHOD void FunctionEffectKindSet::dump(llvm::raw_ostream &OS) const {
5717 OS << "Effects{";
5718 llvm::interleaveComma(*this, OS);
5719 OS << "}";
5720}
5721
5725 assert(llvm::is_sorted(FX) && "effects should be sorted");
5726 assert((Conds.empty() || Conds.size() == FX.size()) &&
5727 "effects size should match conditions size");
5728 return FunctionEffectsRef(FX, Conds);
5729}
5730
5732 std::string Result(Effect.name().str());
5733 if (Cond.getCondition() != nullptr)
5734 Result += "(expr)";
5735 return Result;
5736}
5737
5738const HLSLAttributedResourceType *
5739HLSLAttributedResourceType::findHandleTypeOnResource(const Type *RT) {
5740 // If the type RT is an HLSL resource class, the first field must
5741 // be the resource handle of type HLSLAttributedResourceType
5742 const clang::Type *Ty = RT->getUnqualifiedDesugaredType();
5743 if (const RecordDecl *RD = Ty->getAsCXXRecordDecl()) {
5744 if (!RD->fields().empty()) {
5745 const auto &FirstFD = RD->fields().begin();
5746 return dyn_cast<HLSLAttributedResourceType>(
5747 FirstFD->getType().getTypePtr());
5748 }
5749 }
5750 return nullptr;
5751}
5752
5753StringRef PredefinedSugarType::getName(Kind KD) {
5754 switch (KD) {
5755 case Kind::SizeT:
5756 return "__size_t";
5757 case Kind::SignedSizeT:
5758 return "__signed_size_t";
5759 case Kind::PtrdiffT:
5760 return "__ptrdiff_t";
5761 }
5762 llvm_unreachable("unexpected kind");
5763}
Defines the clang::ASTContext interface.
#define V(N, I)
Provides definitions for the various language-specific address spaces.
static std::optional< NonLoc > getIndex(ProgramStateRef State, const ElementRegion *ER, CharKind CK)
static Decl::Kind getKind(const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
static DeclT * getDefinitionOrSelf(DeclT *D)
Definition Decl.cpp:2691
Defines the ExceptionSpecificationType enumeration and various utility functions.
TokenType getType() const
Returns the token's type, e.g.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
#define CC_VLS_CASE(ABI_VLEN)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
Definition MachO.h:31
static QualType getUnderlyingType(const SubRegion *R)
static RecordDecl * getAsRecordDecl(QualType BaseType, HeuristicResolver &Resolver)
static bool isRecordType(QualType T)
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we're targeting.
static TypeDependence getTemplateSpecializationTypeDependence(QualType Underlying, TemplateName T)
Definition Type.cpp:4584
#define ENUMERATE_ATTRS(PREFIX)
#define SUGARED_TYPE_CLASS(Class)
Definition Type.cpp:1001
static const TemplateTypeParmDecl * getReplacedParameter(Decl *D, unsigned Index)
Definition Type.cpp:4439
TypePropertyCache< Private > Cache
Definition Type.cpp:4792
static bool isTriviallyCopyableTypeImpl(const QualType &type, const ASTContext &Context, bool IsCopyConstructible)
Definition Type.cpp:2816
static const T * getAsSugar(const Type *Cur)
This will check for a T (which should be a Type which can act as sugar, such as a TypedefType) by rem...
Definition Type.cpp:607
#define TRIVIAL_TYPE_CLASS(Class)
Definition Type.cpp:999
static CachedProperties computeCachedProperties(const Type *T)
Definition Type.cpp:4794
C Language Family Type Representation.
Defines the clang::Visibility enumeration and various utility functions.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:188
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
QualType getParenType(QualType NamedType) const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType, const Attr *attr=nullptr) const
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getArrayParameterType(QualType Ty) const
Return the uniqued reference to a specified array parameter type from the original array type.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, UnsignedOrNone PackIndex, bool Final) const
Retrieve a substitution-result type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
CanQualType VoidPtrTy
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
Definition ASTContext.h:891
QualType applyObjCProtocolQualifiers(QualType type, ArrayRef< ObjCProtocolDecl * > protocols, bool &hasError, bool allowOnPointerType=false) const
Apply Objective-C protocol qualifiers to the given type.
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
CanQualType ObjCBuiltinIdTy
IdentifierInfo * getNSObjectName() const
Retrieve the identifier 'NSObject'.
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a non-unique reference to the type for a variable array of the specified element type.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, TemplateDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
CanQualType UnsignedCharTy
TemplateName getQualifiedTemplateName(NestedNameSpecifier Qualifier, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getMemberPointerType(QualType T, NestedNameSpecifier Qualifier, const CXXRecordDecl *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
const TargetInfo & getTargetInfo() const
Definition ASTContext.h:856
QualType getIncompleteArrayType(QualType EltTy, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type.
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
IdentifierInfo * getNSCopyingName()
Retrieve the identifier 'NSCopying'.
QualType getConstantArrayType(const ASTContext &Ctx) const
Definition Type.cpp:279
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition TypeBase.h:3720
ArraySizeModifier getSizeModifier() const
Definition TypeBase.h:3734
Qualifiers getIndexTypeQualifiers() const
Definition TypeBase.h:3738
QualType getElementType() const
Definition TypeBase.h:3732
ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm, unsigned tq, const Expr *sz=nullptr)
Definition Type.cpp:174
Attr - This represents one attribute.
Definition Attr.h:44
BitIntType(bool isUnsigned, unsigned NumBits)
Definition Type.cpp:424
[BoundsSafety] Represents a parent type class for CountAttributedType and similar sugar types that wi...
Definition TypeBase.h:3388
BoundsAttributedType(TypeClass TC, QualType Wrapped, QualType Canon)
Definition Type.cpp:3981
decl_range dependent_decls() const
Definition TypeBase.h:3408
bool referencesFieldDecls() const
Definition Type.cpp:448
This class is used for builtin types like 'int'.
Definition TypeBase.h:3164
Kind getKind() const
Definition TypeBase.h:3212
StringRef getName(const PrintingPolicy &Policy) const
Definition Type.cpp:3363
Represents a C++ struct/union/class.
Definition DeclCXX.h:258
bool isHLSLIntangible() const
Returns true if the class contains HLSL intangible type, either as a field or in base class.
Definition DeclCXX.h:1550
bool mayBeNonDynamicClass() const
Definition DeclCXX.h:586
bool mayBeDynamicClass() const
Definition DeclCXX.h:580
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition DeclCXX.h:522
Declaration of a class template.
Complex values, per C99 6.2.5p11.
Definition TypeBase.h:3275
Represents the canonical version of C arrays with a specified constant size.
Definition TypeBase.h:3758
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
Definition Type.cpp:214
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
Definition Type.cpp:254
friend class ASTContext
Definition TypeBase.h:3759
const Expr * getSizeExpr() const
Return a pointer to the size expression.
Definition TypeBase.h:3854
llvm::APInt getSize() const
Return the constant array size as an APInt.
Definition TypeBase.h:3814
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition TypeBase.h:3873
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition Expr.h:1082
llvm::APSInt getResultAsAPSInt() const
Definition Expr.cpp:397
ConstantMatrixType(QualType MatrixElementType, unsigned NRows, unsigned NColumns, QualType CanonElementType)
Definition Type.cpp:378
unsigned NumRows
Number of rows and columns.
Definition TypeBase.h:4376
Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variant...
Definition TypeBase.h:3436
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3472
StringRef getAttributeName(bool WithMacroPrefix) const
Definition Type.cpp:3998
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition DeclBase.h:1449
ASTContext & getParentASTContext() const
Definition DeclBase.h:2138
Decl - This represents one declaration (or definition), e.g.
Definition DeclBase.h:86
bool isInStdNamespace() const
Definition DeclBase.cpp:427
ASTContext & getASTContext() const LLVM_READONLY
Definition DeclBase.cpp:524
bool hasAttr() const
Definition DeclBase.h:577
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:4081
Expr * getNumBitsExpr() const
Definition Type.cpp:437
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:8182
DependentBitIntType(bool IsUnsigned, Expr *NumBits)
Definition Type.cpp:428
bool isUnsigned() const
Definition Type.cpp:433
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:4038
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:4124
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:4450
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:6214
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:4250
Expr * getCondition() const
Definition TypeBase.h:4991
This represents one expression.
Definition Expr.h:112
bool isValueDependent() const
Determines whether the value of this expression depends on.
Definition Expr.h:177
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
Definition Expr.h:223
QualType getType() const
Definition Expr.h:144
ExprDependence getDependence() const
Definition Expr.h:164
Represents a member of a struct/union/class.
Definition Decl.h:3157
A mutable set of FunctionEffect::Kind.
Definition TypeBase.h:5118
void dump(llvm::raw_ostream &OS) const
Definition Type.cpp:5716
bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs)
Definition Type.cpp:5592
SmallVector< Conflict > Conflicts
Definition TypeBase.h:5232
static FunctionEffectSet getIntersection(FunctionEffectsRef LHS, FunctionEffectsRef RHS)
Definition Type.cpp:5641
void dump(llvm::raw_ostream &OS) const
Definition Type.cpp:5712
static FunctionEffectSet getUnion(FunctionEffectsRef LHS, FunctionEffectsRef RHS, Conflicts &Errs)
Definition Type.cpp:5679
Kind kind() const
The kind of the effect.
Definition TypeBase.h:4916
Kind
Identifies the particular effect.
Definition TypeBase.h:4880
bool shouldDiagnoseFunctionCall(bool Direct, FunctionEffectKindSet CalleeFX) const
Definition Type.cpp:5567
StringRef name() const
The description printed in diagnostics, e.g. 'nonblocking'.
Definition Type.cpp:5529
Kind oppositeKind() const
Return the opposite kind, for effects which have opposites.
Definition Type.cpp:5515
std::optional< FunctionEffect > effectProhibitingInference(const Decl &Callee, FunctionEffectKindSet CalleeFX) const
Determine whether the effect is allowed to be inferred on the callee, which is either a FunctionDecl ...
Definition Type.cpp:5543
An immutable set of FunctionEffects and possibly conditions attached to them.
Definition TypeBase.h:5064
void dump(llvm::raw_ostream &OS) const
Definition Type.cpp:5706
ArrayRef< FunctionEffect > effects() const
Definition TypeBase.h:5097
iterator begin() const
Definition TypeBase.h:5102
ArrayRef< EffectConditionExpr > conditions() const
Definition TypeBase.h:5098
static FunctionEffectsRef create(ArrayRef< FunctionEffect > FX, ArrayRef< EffectConditionExpr > Conds)
Asserts invariants.
Definition Type.cpp:5723
iterator end() const
Definition TypeBase.h:5103
bool hasDependentExceptionSpec() const
Return whether this function has a dependent exception spec.
Definition Type.cpp:3825
param_type_iterator param_type_begin() const
Definition TypeBase.h:5708
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition TypeBase.h:5571
bool isTemplateVariadic() const
Determines whether this function prototype contains a parameter pack at the end.
Definition Type.cpp:3879
unsigned getNumParams() const
Definition TypeBase.h:5542
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition TypeBase.h:5684
QualType getParamType(unsigned i) const
Definition TypeBase.h:5544
QualType getExceptionType(unsigned i) const
Return the ith exception type, where 0 <= i < getNumExceptions().
Definition TypeBase.h:5622
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition Type.cpp:3956
friend class ASTContext
Definition TypeBase.h:5265
unsigned getNumExceptions() const
Return the number of types in the exception specification.
Definition TypeBase.h:5614
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
Definition Type.cpp:3846
ExtProtoInfo getExtProtoInfo() const
Definition TypeBase.h:5553
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
Definition TypeBase.h:5629
ArrayRef< QualType > getParamTypes() const
Definition TypeBase.h:5549
ArrayRef< QualType > exceptions() const
Definition TypeBase.h:5718
bool hasInstantiationDependentExceptionSpec() const
Return whether this function has an instantiation-dependent exception spec.
Definition Type.cpp:3837
A class which abstracts out some details necessary for making a call.
Definition TypeBase.h:4571
ExtInfo getExtInfo() const
Definition TypeBase.h:4816
static StringRef getNameForCallConv(CallingConv CC)
Definition Type.cpp:3578
bool getCFIUncheckedCalleeAttr() const
Determine whether this is a function prototype that includes the cfi_unchecked_callee attribute.
Definition Type.cpp:3572
QualType getReturnType() const
Definition TypeBase.h:4800
FunctionType(TypeClass tc, QualType res, QualType Canonical, TypeDependence Dependence, ExtInfo Info)
Definition TypeBase.h:4786
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
LinkageInfo computeTypeLinkageInfo(const Type *T)
Definition Type.cpp:4909
LinkageInfo getTypeLinkageAndVisibility(const Type *T)
Definition Type.cpp:5009
LinkageInfo getDeclLinkageAndVisibility(const NamedDecl *D)
Definition Decl.cpp:1626
static LinkageInfo external()
Definition Visibility.h:72
Linkage getLinkage() const
Definition Visibility.h:88
void merge(LinkageInfo other)
Merge both linkage and visibility.
Definition Visibility.h:137
QualType desugar() const
Definition Type.cpp:4072
QualType getModifiedType() const
Return this attributed type's modified type with no qualifiers attached to it.
Definition Type.cpp:4074
QualType getUnderlyingType() const
Definition TypeBase.h:6159
const IdentifierInfo * getMacroIdentifier() const
Definition TypeBase.h:6158
Represents a matrix type, as defined in the Matrix Types clang extensions.
Definition TypeBase.h:4335
MatrixType(QualType ElementTy, QualType CanonElementTy)
QualType ElementType
The element type of the matrix.
Definition TypeBase.h:4340
NestedNameSpecifier getQualifier() const
Definition TypeBase.h:3683
bool isSugared() const
Definition Type.cpp:5435
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3694
CXXRecordDecl * getMostRecentCXXRecordDecl() const
Note: this can trigger extra deserialization when external AST sources are used.
Definition Type.cpp:5457
This represents a decl that may have a name.
Definition Decl.h:273
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition Decl.h:294
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier, or null.
ObjCCategoryDecl - Represents a category declaration.
Definition DeclObjC.h:2329
ObjCInterfaceDecl * getClassInterface()
Definition DeclObjC.h:2372
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameter list associated with this category or extension.
Definition DeclObjC.h:2377
Represents an ObjC class declaration.
Definition DeclObjC.h:1154
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
Definition DeclObjC.cpp:319
const ObjCObjectType * getSuperClassType() const
Retrieve the superclass type.
Definition DeclObjC.h:1565
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
Definition DeclObjC.h:1915
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Definition DeclObjC.h:1542
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
Definition TypeBase.h:7847
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition Type.cpp:951
Represents a pointer to an Objective C object.
Definition TypeBase.h:7903
const ObjCObjectPointerType * stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const
Strip off the Objective-C "kindof" type and (with it) any protocol qualifiers.
Definition Type.cpp:958
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition TypeBase.h:7940
QualType getSuperClassType() const
Retrieve the type of the superclass of this object pointer type.
Definition Type.cpp:1850
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
Definition TypeBase.h:7955
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition Type.cpp:1840
bool isKindOfType() const
Whether this is a "__kindof" type.
Definition TypeBase.h:7989
Represents an Objective-C protocol declaration.
Definition DeclObjC.h:2084
Represents the declaration of an Objective-C type parameter.
Definition DeclObjC.h:578
unsigned getIndex() const
Retrieve the index into its type parameter list.
Definition DeclObjC.h:636
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition DeclObjC.h:662
unsigned size() const
Determine the number of type parameters in this list.
Definition DeclObjC.h:689
A (possibly-)qualified type.
Definition TypeBase.h:937
bool hasAddressDiscriminatedPointerAuth() const
Definition TypeBase.h:1457
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition Type.cpp:2867
QualType IgnoreParens() const
Returns the specified type after dropping any outer-level parentheses.
Definition TypeBase.h:1315
QualType withFastQualifiers(unsigned TQs) const
Definition TypeBase.h:1201
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
Definition Type.h:87
bool isWebAssemblyFuncrefType() const
Returns true if it is a WebAssembly Funcref Type.
Definition Type.cpp:2948
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
Definition Type.cpp:3556
@ PDIK_ARCWeak
The type is an Objective-C retainable pointer type that is qualified with the ARC __weak qualifier.
Definition TypeBase.h:1475
@ PDIK_Trivial
The type does not fall into any of the following categories.
Definition TypeBase.h:1467
@ PDIK_ARCStrong
The type is an Objective-C retainable pointer type that is qualified with the ARC __strong qualifier.
Definition TypeBase.h:1471
@ PDIK_Struct
The type is a struct containing a field whose type is not PCK_Trivial.
Definition TypeBase.h:1478
bool mayBeDynamicClass() const
Returns true if it is a class and it might be dynamic.
Definition Type.cpp:130
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
Definition Type.cpp:2921
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
Definition Type.cpp:109
bool isBitwiseCloneableType(const ASTContext &Context) const
Return true if the type is safe to bitwise copy using memcpy/memmove.
Definition Type.cpp:2873
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:1398
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition TypeBase.h:1296
bool isTriviallyCopyConstructibleType(const ASTContext &Context) const
Return true if this is a trivially copyable type.
Definition Type.cpp:2915
bool isTrivialType(const ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
Definition Type.cpp:2758
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition TypeBase.h:1004
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Definition Type.cpp:2970
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition TypeBase.h:8285
LangAS getAddressSpace() const
Return the address space of this type.
Definition TypeBase.h:8411
bool isConstant(const ASTContext &Ctx) const
Definition TypeBase.h:1097
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Definition Type.h:81
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition TypeBase.h:8325
bool isCXX98PODType(const ASTContext &Context) const
Return true if this is a POD type according to the rules of the C++98 standard, regardless of the cur...
Definition Type.cpp:2703
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition TypeBase.h:1438
QualType stripObjCKindOfType(const ASTContext &ctx) const
Strip Objective-C "__kindof" types from the given type.
Definition Type.cpp:1663
QualType getCanonicalType() const
Definition TypeBase.h:8337
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition TypeBase.h:8379
QualType substObjCMemberType(QualType objectType, const DeclContext *dc, ObjCSubstitutionContext context) const
Substitute type arguments from an object type for the Objective-C type parameters used in the subject...
Definition Type.cpp:1654
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
Definition Type.cpp:2940
SplitQualType getSplitDesugaredType() const
Definition TypeBase.h:1300
std::optional< NonConstantStorageReason > isNonConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
Determine whether instances of this type can be placed in immutable storage.
Definition Type.cpp:151
QualType()=default
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition TypeBase.h:8306
bool UseExcessPrecision(const ASTContext &Ctx)
Definition Type.cpp:1612
PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C struct types.
Definition Type.cpp:2954
void * getAsOpaquePtr() const
Definition TypeBase.h:984
bool isWebAssemblyExternrefType() const
Returns true if it is a WebAssembly Externref Type.
Definition Type.cpp:2944
QualType getNonPackExpansionType() const
Remove an outer pack expansion type (if any) from this type.
Definition Type.cpp:3549
bool isCXX11PODType(const ASTContext &Context) const
Return true if this is a POD type according to the more relaxed rules of the C++11 standard,...
Definition Type.cpp:3112
bool mayBeNotDynamicClass() const
Returns true if it is not a class or if the class might not be dynamic.
Definition Type.cpp:135
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition TypeBase.h:8358
QualType substObjCTypeArgs(ASTContext &ctx, ArrayRef< QualType > typeArgs, ObjCSubstitutionContext context) const
Substitute type arguments for the Objective-C type parameters used in the subject type.
Definition Type.cpp:1647
QualType getAtomicUnqualifiedType() const
Remove all qualifiers including _Atomic.
Definition Type.cpp:1670
bool hasNonTrivialObjCLifetime() const
Definition TypeBase.h:1442
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition Type.cpp:2695
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Definition Type.cpp:2990
@ PCK_Struct
The type is a struct containing a field whose type is neither PCK_Trivial nor PCK_VolatileTrivial.
Definition TypeBase.h:1517
@ PCK_Trivial
The type does not fall into any of the following categories.
Definition TypeBase.h:1493
@ PCK_ARCStrong
The type is an Objective-C retainable pointer type that is qualified with the ARC __strong qualifier.
Definition TypeBase.h:1502
@ PCK_VolatileTrivial
The type would be trivial except that it is volatile-qualified.
Definition TypeBase.h:1498
@ PCK_PtrAuth
The type is an address-discriminated signed pointer type.
Definition TypeBase.h:1509
@ PCK_ARCWeak
The type is an Objective-C retainable pointer type that is qualified with the ARC __weak qualifier.
Definition TypeBase.h:1506
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
Definition Type.h:75
A qualifier set is used to build a set of qualifiers.
Definition TypeBase.h:8225
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition TypeBase.h:8232
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Definition Type.cpp:4666
The collection of all-type qualifiers we support.
Definition TypeBase.h:331
GC getObjCGCAttr() const
Definition TypeBase.h:519
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
Definition TypeBase.h:361
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
Definition TypeBase.h:354
@ OCL_None
There is no lifetime qualification on this type.
Definition TypeBase.h:350
@ OCL_Weak
Reading or writing from this object requires a barrier call.
Definition TypeBase.h:364
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
Definition TypeBase.h:367
bool isStrictSupersetOf(Qualifiers Other) const
Determine whether this set of qualifiers is a strict superset of another set of qualifiers,...
Definition Type.cpp:57
bool hasNonFastQualifiers() const
Return true if the set contains any qualifiers which require an ExtQuals node to be allocated.
Definition TypeBase.h:638
void addConsistentQualifiers(Qualifiers qs)
Add the qualifiers from the given set to this set, given that they don't conflict.
Definition TypeBase.h:689
static bool isTargetAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
Definition Type.cpp:72
bool hasAddressSpace() const
Definition TypeBase.h:570
unsigned getFastQualifiers() const
Definition TypeBase.h:619
bool hasVolatile() const
Definition TypeBase.h:467
bool hasObjCGCAttr() const
Definition TypeBase.h:518
bool hasObjCLifetime() const
Definition TypeBase.h:544
ObjCLifetime getObjCLifetime() const
Definition TypeBase.h:545
LangAS getAddressSpace() const
Definition TypeBase.h:571
Qualifiers()=default
Represents a struct/union/class.
Definition Decl.h:4309
bool hasNonTrivialToPrimitiveDestructCUnion() const
Definition Decl.h:4419
bool hasNonTrivialToPrimitiveCopyCUnion() const
Definition Decl.h:4427
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Definition Decl.h:4411
bool isNonTrivialToPrimitiveDestroy() const
Definition Decl.h:4403
bool isNonTrivialToPrimitiveCopy() const
Definition Decl.h:4395
field_range fields() const
Definition Decl.h:4512
RecordDecl * getMostRecentDecl()
Definition Decl.h:4335
bool isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C structs.
Definition Decl.h:4387
Declaration of a redeclarable template.
Encodes a location in the source.
Stmt - This represents one statement.
Definition Stmt.h:85
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
void dump() const
Dumps the specified AST fragment and all subtrees to llvm::errs().
Represents the declaration of a struct/union/class/enum.
Definition Decl.h:3714
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition Decl.h:3809
NestedNameSpecifier getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
Definition Decl.h:3954
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition Decl.h:3854
Exposes information about the current target.
Definition TargetInfo.h:226
virtual bool hasFullBFloat16Type() const
Determine whether the BFloat type is fully supported on this target, i.e arithemtic operations.
Definition TargetInfo.h:724
virtual bool hasFastHalfType() const
Determine whether the target has fast native support for operations on half types.
Definition TargetInfo.h:706
virtual bool hasFloat16Type() const
Determine whether the _Float16 type is supported on this target.
Definition TargetInfo.h:715
virtual bool hasBFloat16Type() const
Determine whether the _BFloat16 type is supported on this target.
Definition TargetInfo.h:718
virtual bool isAddressSpaceSupersetOf(LangAS A, LangAS B) const
Returns true if an address space can be safely converted to another.
Definition TargetInfo.h:507
A convenient class for passing around template argument information.
ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
Represents a template argument.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
@ Type
The template argument is a type.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Represents a C++ template name within the type system.
Declaration of a template type parameter.
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
Definition TypeBase.h:3356
ValueDecl * getDecl() const
Definition Type.cpp:3968
bool operator==(const TypeCoupledDeclRefInfo &Other) const
Definition Type.cpp:3973
void * getOpaqueValue() const
Definition Type.cpp:3970
TypeCoupledDeclRefInfo(ValueDecl *D=nullptr, bool Deref=false)
D is to a declaration referenced by the argument of attribute.
Definition Type.cpp:3962
unsigned getInt() const
Definition Type.cpp:3969
void setFromOpaqueValue(void *V)
Definition Type.cpp:3977
bool isSugared() const
Returns whether this type directly provides sugar.
Definition Type.cpp:4101
TypeOfKind getKind() const
Returns the kind of 'typeof' type this is.
Definition TypeBase.h:6189
TypeOfExprType(const ASTContext &Context, Expr *E, TypeOfKind Kind, QualType Can=QualType())
Definition Type.cpp:4086
friend class ASTContext
Definition TypeBase.h:6180
Expr * getUnderlyingExpr() const
Definition TypeBase.h:6186
QualType desugar() const
Remove a single level of sugar.
Definition Type.cpp:4103
The type-property cache.
Definition Type.cpp:4747
static void ensure(const Type *T)
Definition Type.cpp:4757
static CachedProperties get(QualType T)
Definition Type.cpp:4749
static CachedProperties get(const Type *T)
Definition Type.cpp:4751
An operation on a type.
Definition TypeVisitor.h:64
A helper class for Type nodes having an ElaboratedTypeKeyword.
Definition TypeBase.h:5951
The base class of the type hierarchy.
Definition TypeBase.h:1833
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
Definition Type.cpp:2568
bool isStructureType() const
Definition Type.cpp:678
bool isBlockPointerType() const
Definition TypeBase.h:8542
const ObjCObjectPointerType * getAsObjCQualifiedClassType() const
Definition Type.cpp:1883
bool isLinkageValid() const
True if the computed linkage is valid.
Definition Type.cpp:4999
bool isVoidType() const
Definition TypeBase.h:8878
TypedefBitfields TypedefBits
Definition TypeBase.h:2319
UsingBitfields UsingBits
Definition TypeBase.h:2321
bool isBooleanType() const
Definition TypeBase.h:9008
const ObjCObjectType * getAsObjCQualifiedInterfaceType() const
Definition Type.cpp:1859
const ObjCObjectPointerType * getAsObjCQualifiedIdType() const
Definition Type.cpp:1873
const TemplateSpecializationType * getAsNonAliasTemplateSpecializationType() const
Look through sugar for an instance of TemplateSpecializationType which is not a type alias,...
Definition Type.cpp:1921
bool isMFloat8Type() const
Definition TypeBase.h:8903
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition Type.cpp:2225
bool isPackedVectorBoolType(const ASTContext &ctx) const
Definition Type.cpp:418
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
Definition Type.cpp:1951
bool isAlwaysIncompleteType() const
Definition Type.cpp:2516
QualType getRVVEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an RVV builtin type.
Definition Type.cpp:2678
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition Type.cpp:787
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition Type.cpp:2994
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
Definition Type.cpp:2205
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition Type.cpp:724
ArrayTypeBitfields ArrayTypeBits
Definition TypeBase.h:2314
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
Definition TypeBase.h:9174
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition Type.cpp:2273
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition Type.cpp:2115
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition Type.h:26
VectorTypeBitfields VectorTypeBits
Definition TypeBase.h:2328
bool isNothrowT() const
Definition Type.cpp:3171
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Definition Type.h:41
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
Definition Type.cpp:2066
bool isVoidPointerType() const
Definition Type.cpp:712
const ComplexType * getAsComplexIntegerType() const
Definition Type.cpp:745
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
Definition Type.cpp:2426
bool isArrayType() const
Definition TypeBase.h:8621
bool isCharType() const
Definition Type.cpp:2132
QualType getLocallyUnqualifiedSingleStepDesugaredType() const
Pull a single level of sugar off of this locally-unqualified type.
Definition Type.cpp:521
bool isFunctionPointerType() const
Definition TypeBase.h:8589
bool isCountAttributedType() const
Definition Type.cpp:741
bool isObjCARCBridgableType() const
Determine whether the given type T is a "bridgable" Objective-C type, which is either an Objective-C ...
Definition Type.cpp:5319
CXXRecordDecl * castAsCXXRecordDecl() const
Definition Type.h:36
bool isArithmeticType() const
Definition Type.cpp:2337
bool isHLSLBuiltinIntangibleType() const
Definition TypeBase.h:8823
TypeOfBitfields TypeOfBits
Definition TypeBase.h:2318
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition TypeBase.h:8922
bool isSVESizelessBuiltinType() const
Returns true for SVE scalable vector types.
Definition Type.cpp:2574
const T * castAs() const
Member-template castAs<specific type>.
Definition TypeBase.h:9165
bool isReferenceType() const
Definition TypeBase.h:8546
bool isHLSLIntangibleType() const
Definition Type.cpp:5383
bool isEnumeralType() const
Definition TypeBase.h:8653
void addDependence(TypeDependence D)
Definition TypeBase.h:2372
bool isObjCNSObjectType() const
Definition Type.cpp:5279
Type(TypeClass tc, QualType canon, TypeDependence Dependence)
Definition TypeBase.h:2349
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition Type.cpp:1901
NestedNameSpecifier getPrefix() const
If this type represents a qualified-id, this returns its nested name specifier.
Definition Type.cpp:1928
bool isScalarType() const
Definition TypeBase.h:8980
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.
Definition Type.cpp:1909
bool isInterfaceType() const
Definition Type.cpp:700
bool isVariableArrayType() const
Definition TypeBase.h:8633
bool isChar8Type() const
Definition Type.cpp:2148
bool isSizelessBuiltinType() const
Definition Type.cpp:2532
bool isCUDADeviceBuiltinSurfaceType() const
Check if the type is the CUDA device builtin surface type.
Definition Type.cpp:5334
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
Definition Type.cpp:2608
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition Type.cpp:2103
bool isElaboratedTypeSpecifier() const
Determine wither this type is a C++ elaborated-type-specifier.
Definition Type.cpp:3331
CountAttributedTypeBitfields CountAttributedTypeBits
Definition TypeBase.h:2334
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
Definition Type.cpp:471
bool isAlignValT() const
Definition Type.cpp:3180
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition Type.cpp:752
LinkageInfo getLinkageAndVisibility() const
Determine the linkage and visibility of this type.
Definition Type.cpp:5018
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e....
Definition Type.cpp:2291
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition Type.cpp:2168
bool isExtVectorBoolType() const
Definition TypeBase.h:8669
bool isWebAssemblyExternrefType() const
Check if this is a WebAssembly Externref Type.
Definition Type.cpp:2552
bool canHaveNullability(bool ResultIfUnknown=true) const
Determine whether the given type can have a nullability specifier applied to it, i....
Definition Type.cpp:5035
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
Definition Type.cpp:2647
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition TypeBase.h:2790
bool isLValueReferenceType() const
Definition TypeBase.h:8550
bool isBitIntType() const
Definition TypeBase.h:8787
bool isBuiltinType() const
Helper methods to distinguish type categories.
Definition TypeBase.h:8645
bool isStructuralType() const
Determine if this type is a structural type, per C++20 [temp.param]p7.
Definition Type.cpp:3059
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition TypeBase.h:2782
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
Definition Type.cpp:2411
bool isCARCBridgableType() const
Determine whether the given type T is a "bridgeable" C type.
Definition Type.cpp:5324
bool isSignableIntegerType(const ASTContext &Ctx) const
Definition Type.cpp:5215
RecordDecl * castAsRecordDecl() const
Definition Type.h:48
TypeBitfields TypeBits
Definition TypeBase.h:2313
bool isChar16Type() const
Definition Type.cpp:2154
bool isAnyComplexType() const
Definition TypeBase.h:8657
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
Definition Type.cpp:2056
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition TypeBase.h:2405
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
Definition Type.cpp:2364
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
Definition Type.cpp:2243
QualType getCanonicalTypeInternal() const
Definition TypeBase.h:3119
friend class ASTContext
Definition TypeBase.h:2347
const RecordType * getAsStructureType() const
Definition Type.cpp:768
const char * getTypeClassName() const
Definition Type.cpp:3351
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
Definition Type.cpp:2558
@ PtrdiffT
The "ptrdiff_t" type.
Definition TypeBase.h:2281
@ SizeT
The "size_t" type.
Definition TypeBase.h:2275
@ SignedSizeT
The signed integer type corresponding to "size_t".
Definition TypeBase.h:2278
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition TypeBase.h:9051
AttributedTypeBitfields AttributedTypeBits
Definition TypeBase.h:2316
bool isObjCBoxableRecordType() const
Definition Type.cpp:694
bool isChar32Type() const
Definition Type.cpp:2160
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
Definition Type.cpp:3075
TagTypeBitfields TagTypeBits
Definition TypeBase.h:2327
EnumDecl * castAsEnumDecl() const
Definition Type.h:59
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition TypeBase.h:2800
bool isComplexIntegerType() const
Definition Type.cpp:730
bool isUnscopedEnumerationType() const
Definition Type.cpp:2125
bool isStdByteType() const
Definition Type.cpp:3190
UnresolvedUsingBitfields UnresolvedUsingBits
Definition TypeBase.h:2320
bool isCUDADeviceBuiltinTextureType() const
Check if the type is the CUDA device builtin texture type.
Definition Type.cpp:5343
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
Definition Type.cpp:5221
bool isObjCClassOrClassKindOfType() const
Whether the type is Objective-C 'Class' or a __kindof type of an Class type, e.g.,...
Definition Type.cpp:834
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
Definition TypeBase.h:9151
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition Type.cpp:5310
bool isHLSLResourceRecord() const
Definition Type.cpp:5370
EnumDecl * getAsEnumDecl() const
Retrieves the EnumDecl this type refers to.
Definition Type.h:53
bool isObjCIndirectLifetimeType() const
Definition Type.cpp:5296
bool hasUnnamedOrLocalType() const
Whether this type is or contains a local or unnamed type.
Definition Type.cpp:4904
bool isPointerOrReferenceType() const
Definition TypeBase.h:8526
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
Definition Type.cpp:5254
FunctionTypeBitfields FunctionTypeBits
Definition TypeBase.h:2323
bool isObjCQualifiedInterfaceType() const
Definition Type.cpp:1869
bool isSpecifierType() const
Returns true if this type can be represented by some set of type specifiers.
Definition Type.cpp:3200
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
Definition Type.cpp:2436
bool isObjCObjectPointerType() const
Definition TypeBase.h:8691
bool isStructureTypeWithFlexibleArrayMember() const
Definition Type.cpp:684
TypeDependence getDependence() const
Definition TypeBase.h:2771
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
Definition Type.cpp:2312
bool isStructureOrClassType() const
Definition Type.cpp:706
bool isVectorType() const
Definition TypeBase.h:8661
bool isRVVVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'riscv_rvv_vector_bits' type attribute,...
Definition Type.cpp:2660
bool isRealFloatingType() const
Floating point categories.
Definition Type.cpp:2320
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
Definition Type.cpp:2595
std::optional< ArrayRef< QualType > > getObjCSubstitutions(const DeclContext *dc) const
Retrieve the set of substitutions required when accessing a member of the Objective-C receiver type t...
Definition Type.cpp:1678
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
Definition TypeBase.h:2921
Linkage getLinkage() const
Determine the linkage of this type.
Definition Type.cpp:4899
ObjCObjectTypeBitfields ObjCObjectTypeBits
Definition TypeBase.h:2324
@ STK_FloatingComplex
Definition TypeBase.h:2764
@ STK_ObjCObjectPointer
Definition TypeBase.h:2758
@ STK_IntegralComplex
Definition TypeBase.h:2763
@ STK_MemberPointer
Definition TypeBase.h:2759
bool isFloatingType() const
Definition Type.cpp:2304
const ObjCObjectType * getAsObjCInterfaceType() const
Definition Type.cpp:1893
bool isWideCharType() const
Definition Type.cpp:2141
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition Type.cpp:2253
bool isRealType() const
Definition Type.cpp:2326
bool isClassType() const
Definition Type.cpp:672
bool hasSizedVLAType() const
Whether this type involves a variable-length array type with a definite size.
Definition Type.cpp:5351
TypeClass getTypeClass() const
Definition TypeBase.h:2385
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
Definition TypeBase.h:2411
bool hasAutoForTrailingReturnType() const
Determine whether this type was written with a leading 'auto' corresponding to a trailing return type...
Definition Type.cpp:2061
bool isObjCIdOrObjectKindOfType(const ASTContext &ctx, const ObjCObjectType *&bound) const
Whether the type is Objective-C 'id' or a __kindof type of an object type, e.g., __kindof NSView * or...
Definition Type.cpp:807
const T * getAs() const
Member-template getAs<specific type>'.
Definition TypeBase.h:9098
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
Definition Type.cpp:653
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
Definition Type.cpp:5260
bool isRecordType() const
Definition TypeBase.h:8649
bool isHLSLResourceRecordArray() const
Definition Type.cpp:5374
bool isObjCRetainableType() const
Definition Type.cpp:5291
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
Definition Type.cpp:5022
bool isObjCIndependentClassType() const
Definition Type.cpp:5285
bool isUnionType() const
Definition Type.cpp:718
bool isSizelessVectorType() const
Returns true for all scalable vector types.
Definition Type.cpp:2570
bool isScopedEnumeralType() const
Determine whether this type is a scoped enumeration type.
Definition Type.cpp:735
bool acceptsObjCTypeParams() const
Determines if this is an ObjC interface type that may accept type parameters.
Definition Type.cpp:1759
QualType getSizelessVectorEltType(const ASTContext &Ctx) const
Returns the representative type for the element of a sizeless vector builtin type.
Definition Type.cpp:2635
bool isUnicodeCharacterType() const
Definition Type.cpp:2188
bool hasBooleanRepresentation() const
Determine whether this type has a boolean representation – i.e., it is a boolean type,...
Definition Type.cpp:2354
Base class for declarations which introduce a typedef-name.
Definition Decl.h:3559
QualType getUnderlyingType() const
Definition Decl.h:3614
QualType desugar() const
Definition Type.cpp:4041
bool typeMatchesDecl() const
Definition TypeBase.h:6117
Represents a dependent using declaration which was marked with typename.
Definition DeclCXX.h:4037
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition DeclCXX.h:3399
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition Decl.h:711
Represents a GCC generic vector type.
Definition TypeBase.h:4173
VectorType(QualType vecType, unsigned nElements, QualType canonType, VectorKind vecKind)
Definition Type.cpp:407
QualType ElementType
The element type of the vector.
Definition TypeBase.h:4178
QualType getElementType() const
Definition TypeBase.h:4187
Defines the Linkage enumeration and various utility functions.
Defines the clang::TargetInfo interface.
mlir::Type getBaseType(mlir::Value varPtr)
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
const internal::VariadicAllOfMatcher< Attr > attr
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
const AstTypeMatcher< TypedefType > typedefType
The JSON file list parser is used to communicate input to InstallAPI.
@ TST_struct
Definition Specifiers.h:81
@ TST_class
Definition Specifiers.h:82
@ TST_union
Definition Specifiers.h:80
@ TST_typename
Definition Specifiers.h:84
@ TST_enum
Definition Specifiers.h:79
@ TST_interface
Definition Specifiers.h:83
@ Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
Definition Sema.h:812
bool isa(CodeGen::Address addr)
Definition Address.h:330
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
Definition TypeBase.h:1792
CanThrowResult
Possible results from evaluation of a noexcept expression.
TypeDependenceScope::TypeDependence TypeDependence
void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
Linkage minLinkage(Linkage L1, Linkage L2)
Compute the minimum linkage given two linkages.
Definition Linkage.h:129
@ Nullable
Values of this type can be null.
Definition Specifiers.h:352
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
Definition Specifiers.h:357
@ NonNull
Values of this type can never be null.
Definition Specifiers.h:350
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
Definition Parser.h:61
bool IsEnumDeclComplete(EnumDecl *ED)
Check if the given decl is complete.
Definition Decl.h:5347
bool isPackProducingBuiltinTemplateName(TemplateName N)
ExprDependence computeDependence(FullExpr *E)
@ Private
'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel loop', and 'serial loop' constru...
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
TypeOfKind
The kind of 'typeof' expression we're after.
Definition TypeBase.h:918
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
TypeDependence toTypeDependence(ExprDependence D)
ExprDependence turnValueToTypeDependence(ExprDependence D)
@ Dependent
Parse the block as a dependent block, which may be used in some template instantiations but not other...
Definition Parser.h:142
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition Linkage.h:24
@ External
External linkage, which indicates that the entity can be referred to from other translation units.
Definition Linkage.h:58
ObjCSubstitutionContext
The kind of type we are substituting Objective-C type arguments into.
Definition TypeBase.h:900
@ Superclass
The superclass of a type.
Definition TypeBase.h:914
@ Result
The result type of a method or function.
Definition TypeBase.h:905
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition TypeBase.h:3717
const FunctionProtoType * T
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
@ Template
We are parsing a template declaration.
Definition Parser.h:81
TagTypeKind
The kind of a tag type.
Definition TypeBase.h:5888
@ Interface
The "__interface" keyword.
Definition TypeBase.h:5893
@ Struct
The "struct" keyword.
Definition TypeBase.h:5890
@ Class
The "class" keyword.
Definition TypeBase.h:5899
@ Union
The "union" keyword.
Definition TypeBase.h:5896
@ Enum
The "enum" keyword.
Definition TypeBase.h:5902
@ Keyword
The name has been typo-corrected to a keyword.
Definition Sema.h:560
@ Type
The name was classified as a type.
Definition Sema.h:562
LangAS
Defines the address space values used by the address space qualifier of QualType.
void FixedPointValueToString(SmallVectorImpl< char > &Str, llvm::APSInt Val, unsigned Scale)
Definition Type.cpp:5464
bool isPtrSizeAddressSpace(LangAS AS)
TemplateParameterList * getReplacedTemplateParameterList(const Decl *D)
Internal helper used by Subst* nodes to retrieve the parameter list for their AssociatedDecl.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition Specifiers.h:278
@ CC_X86Pascal
Definition Specifiers.h:284
@ CC_Swift
Definition Specifiers.h:293
@ CC_IntelOclBicc
Definition Specifiers.h:290
@ CC_PreserveMost
Definition Specifiers.h:295
@ CC_Win64
Definition Specifiers.h:285
@ CC_X86ThisCall
Definition Specifiers.h:282
@ CC_AArch64VectorCall
Definition Specifiers.h:297
@ CC_DeviceKernel
Definition Specifiers.h:292
@ CC_AAPCS
Definition Specifiers.h:288
@ CC_PreserveNone
Definition Specifiers.h:300
@ CC_M68kRTD
Definition Specifiers.h:299
@ CC_SwiftAsync
Definition Specifiers.h:294
@ CC_X86RegCall
Definition Specifiers.h:287
@ CC_RISCVVectorCall
Definition Specifiers.h:301
@ CC_X86VectorCall
Definition Specifiers.h:283
@ CC_SpirFunction
Definition Specifiers.h:291
@ CC_AArch64SVEPCS
Definition Specifiers.h:298
@ CC_X86StdCall
Definition Specifiers.h:280
@ CC_X86_64SysV
Definition Specifiers.h:286
@ CC_PreserveAll
Definition Specifiers.h:296
@ CC_X86FastCall
Definition Specifiers.h:281
@ CC_AAPCS_VFP
Definition Specifiers.h:289
U cast(CodeGen::Address addr)
Definition Address.h:327
@ None
The alignment was not explicit in code.
Definition ASTContext.h:146
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition TypeBase.h:5863
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5868
@ None
No keyword precedes the qualified type name.
Definition TypeBase.h:5884
@ Struct
The "struct" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5865
@ Class
The "class" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5874
@ Union
The "union" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5871
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5877
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition TypeBase.h:5881
TypeDependence toSemanticDependence(TypeDependence D)
TypeDependence toSyntacticDependence(TypeDependence D)
@ Other
Other implicit parameter.
Definition Decl.h:1745
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ EST_Uninstantiated
not instantiated yet
@ EST_Unparsed
not parsed yet
@ EST_NoThrow
Microsoft __declspec(nothrow) extension.
@ EST_None
no exception specification
@ EST_MSAny
Microsoft throw(...) extension.
@ EST_BasicNoexcept
noexcept
@ EST_NoexceptFalse
noexcept(expression), evals to 'false'
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_NoexceptTrue
noexcept(expression), evals to 'true'
@ EST_Dynamic
throw(T1, T2)
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
#define false
Definition stdbool.h:26
A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....
Definition TypeBase.h:5001
FunctionEffectWithCondition(FunctionEffect E, const EffectConditionExpr &C)
Definition TypeBase.h:5005
std::string description() const
Return a textual description of the effect, and its condition, if any.
Definition Type.cpp:5731
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition TypeBase.h:5333
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
Definition TypeBase.h:5337
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition TypeBase.h:5323
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition TypeBase.h:5326
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Definition TypeBase.h:5329
Extra information about a function prototype.
Definition TypeBase.h:5349
FunctionTypeExtraAttributeInfo ExtraAttributeInfo
Definition TypeBase.h:5357
bool requiresFunctionProtoTypeArmAttributes() const
Definition TypeBase.h:5395
const ExtParameterInfo * ExtParameterInfos
Definition TypeBase.h:5354
bool requiresFunctionProtoTypeExtraAttributeInfo() const
Definition TypeBase.h:5399
bool requiresFunctionProtoTypeExtraBitfields() const
Definition TypeBase.h:5388
StringRef CFISalt
A CFI "salt" that differentiates functions with the same prototype.
Definition TypeBase.h:4726
A simple holder for various uncommon bits which do not fit in FunctionTypeBitfields.
Definition TypeBase.h:4700
static StringRef getKeywordName(ElaboratedTypeKeyword Keyword)
Definition Type.cpp:3310
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition Type.cpp:3259
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
Definition Type.cpp:3276
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition Type.cpp:3241
static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword)
Definition Type.cpp:3295
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
Definition Type.cpp:3222
Describes how types, statements, expressions, and declarations should be printed.
unsigned Bool
Whether we can use 'bool' rather than '_Bool' (even if the language doesn't actually have 'bool',...
unsigned NullptrTypeInNamespace
Whether 'nullptr_t' is in namespace 'std' or not.
unsigned Half
When true, print the half-precision floating-point type as 'half' instead of '__fp16'.
unsigned MSWChar
When true, print the built-in wchar_t type as __wchar_t.
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition TypeBase.h:870
const Type * Ty
The locally-unqualified type.
Definition TypeBase.h:872
Qualifiers Quals
The local qualifiers.
Definition TypeBase.h:875
constexpr unsigned toInternalRepresentation() const