philnik updated this revision to Diff 510865.
philnik marked 5 inline comments as done.
philnik added a comment.
Address comments
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D147175/new/
https://reviews.llvm.org/D147175
Files:
clang/docs/LanguageExtensions.rst
clang/include/clang/AST/ASTContext.h
clang/include/clang/AST/DeclCXX.h
clang/include/clang/AST/Type.h
clang/include/clang/Basic/TokenKinds.def
clang/lib/AST/ASTContext.cpp
clang/lib/AST/Type.cpp
clang/lib/Sema/SemaExprCXX.cpp
clang/test/SemaCXX/type-traits.cpp
libcxx/include/__algorithm/equal.h
libcxx/include/__string/constexpr_c_functions.h
libcxx/include/__type_traits/is_equality_comparable.h
libcxx/test/libcxx/type_traits/is_trivially_comparable.compile.pass.cpp
Index: libcxx/test/libcxx/type_traits/is_trivially_comparable.compile.pass.cpp
===================================================================
--- libcxx/test/libcxx/type_traits/is_trivially_comparable.compile.pass.cpp
+++ libcxx/test/libcxx/type_traits/is_trivially_comparable.compile.pass.cpp
@@ -13,32 +13,32 @@
enum Enum : int {};
enum class EnumClass : int {};
-static_assert(std::__is_trivially_equality_comparable<int, int>::value, "");
-static_assert(std::__is_trivially_equality_comparable<const int, int>::value, "");
-static_assert(std::__is_trivially_equality_comparable<int, const int>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<int, int>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<const int, int>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<int, const int>::value, "");
-static_assert(std::__is_trivially_equality_comparable<unsigned int, unsigned int>::value, "");
-static_assert(std::__is_trivially_equality_comparable<const unsigned int, unsigned int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<unsigned int, int>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<unsigned int, unsigned int>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<const unsigned int, unsigned int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<unsigned int, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<long, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<int, long>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<long, int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<int, long>::value, "");
-static_assert(std::__is_trivially_equality_comparable<int*, int*>::value, "");
-static_assert(std::__is_trivially_equality_comparable<int*, void*>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<int*, long*>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<int*, int*>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<int*, void*>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<int*, long*>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<Enum, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<EnumClass, int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<Enum, int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<EnumClass, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<float, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<double, long long>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<float, int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<double, long long>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<float, int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<float, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<float, float>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<double, double>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<long double, long double>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<float, float>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<double, double>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<long double, long double>::value, "");
struct S {
char c;
@@ -51,8 +51,8 @@
struct VirtualBase : virtual S {};
struct NonVirtualBase : S, S2 {};
-static_assert(!std::__is_trivially_equality_comparable<S*, VirtualBase*>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<S2*, VirtualBase*>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<S*, VirtualBase*>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<S2*, VirtualBase*>::value, "");
// This is trivially_equality_comparable, but we can't detect it currently
-static_assert(!std::__is_trivially_equality_comparable<S*, NonVirtualBase*>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<S*, NonVirtualBase*>::value, "");
Index: libcxx/include/__type_traits/is_equality_comparable.h
===================================================================
--- libcxx/include/__type_traits/is_equality_comparable.h
+++ libcxx/include/__type_traits/is_equality_comparable.h
@@ -43,14 +43,14 @@
// always compared.
template <class _Tp, class _Up>
-struct __is_trivially_equality_comparable
+struct __libcpp_is_trivially_equality_comparable
: integral_constant<bool,
__is_equality_comparable<_Tp, _Up>::value && is_integral<_Tp>::value &&
is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up> >::value> {};
// TODO: Use is_pointer_inverconvertible_base_of
template <class _Tp, class _Up>
-struct __is_trivially_equality_comparable<_Tp*, _Up*>
+struct __libcpp_is_trivially_equality_comparable<_Tp*, _Up*>
: integral_constant<
bool,
__is_equality_comparable<_Tp*, _Up*>::value &&
Index: libcxx/include/__string/constexpr_c_functions.h
===================================================================
--- libcxx/include/__string/constexpr_c_functions.h
+++ libcxx/include/__string/constexpr_c_functions.h
@@ -39,7 +39,7 @@
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int
__constexpr_memcmp(const _Tp* __lhs, const _Up* __rhs, size_t __count) {
static_assert(
- __is_trivially_equality_comparable<_Tp, _Up>::value, "_Tp and _Up have to be trivially equality comparable");
+ __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value, "_Tp and _Up have to be trivially equality comparable");
if (__libcpp_is_constant_evaluated()) {
#ifdef _LIBCPP_COMPILER_CLANG_BASED
Index: libcxx/include/__algorithm/equal.h
===================================================================
--- libcxx/include/__algorithm/equal.h
+++ libcxx/include/__algorithm/equal.h
@@ -46,7 +46,7 @@
class _Up,
class _BinaryPredicate,
__enable_if_t<__is_trivial_equality_predicate<_BinaryPredicate, _Tp, _Up>::value && !is_volatile<_Tp>::value &&
- !is_volatile<_Up>::value && __is_trivially_equality_comparable<_Tp, _Up>::value,
+ !is_volatile<_Up>::value && __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
int> = 0>
_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
__equal_iter_impl(_Tp* __first1, _Tp* __last1, _Up* __first2, _BinaryPredicate&) {
@@ -96,7 +96,7 @@
class _Proj2,
__enable_if_t<__is_trivial_equality_predicate<_Pred, _Tp, _Up>::value && __is_identity<_Proj1>::value &&
__is_identity<_Proj2>::value && !is_volatile<_Tp>::value && !is_volatile<_Up>::value &&
- __is_trivially_equality_comparable<_Tp, _Up>::value,
+ __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
int> = 0>
_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_impl(
_Tp* __first1, _Tp* __last1, _Up* __first2, _Up*, _Pred&, _Proj1&, _Proj2&) {
Index: clang/test/SemaCXX/type-traits.cpp
===================================================================
--- clang/test/SemaCXX/type-traits.cpp
+++ clang/test/SemaCXX/type-traits.cpp
@@ -1,6 +1,7 @@
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fblocks -Wno-deprecated-builtins %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++17 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++20 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s
#define T(b) (b) ? 1 : -1
#define F(b) (b) ? -1 : 1
@@ -570,7 +571,11 @@
static_assert(__is_aggregate(DerivesAr), "");
static_assert(__is_aggregate(DerivesArNB), "");
static_assert(!__is_aggregate(HasCons), "");
+#if __cplusplus >= 202002L
+ static_assert(!__is_aggregate(HasDefaultCons), "");
+#else
static_assert(__is_aggregate(HasDefaultCons), "");
+#endif
static_assert(!__is_aggregate(HasExplicitDefaultCons), "");
static_assert(!__is_aggregate(HasInheritedCons), "");
static_assert(__is_aggregate(HasNoInheritedCons) == TrueAfterCpp14, "");
@@ -3055,6 +3060,148 @@
} // namespace is_trivially_relocatable
+namespace is_trivially_equality_comparable {
+struct ForwardDeclared; // expected-note {{forward declaration of 'is_trivially_equality_comparable::ForwardDeclared'}}
+static_assert(!__is_trivially_equality_comparable(ForwardDeclared), ""); // expected-error {{incomplete type 'ForwardDeclared' used in type trait expression}}
+
+static_assert(!__is_trivially_equality_comparable(void), "");
+static_assert(__is_trivially_equality_comparable(int), "");
+static_assert(!__is_trivially_equality_comparable(int[]), "");
+static_assert(__is_trivially_equality_comparable(int[3]), "");
+static_assert(!__is_trivially_equality_comparable(float), "");
+static_assert(!__is_trivially_equality_comparable(double), "");
+static_assert(!__is_trivially_equality_comparable(long double), "");
+
+struct TriviallyEqualityComparableNoDefaultedComparator {
+ int i;
+ int j;
+};
+static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparableNoDefaultedComparator), "");
+
+#if __cplusplus >= 202002L
+
+struct TriviallyEqualityComparable {
+ int i;
+ int j;
+
+ void func();
+ bool operator==(int) const { return false; }
+
+ bool operator==(const TriviallyEqualityComparable&) const = default;
+};
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable), "");
+
+struct NotTriviallyEqualityComparableHasPadding {
+ short i;
+ int j;
+
+ bool operator==(const NotTriviallyEqualityComparableHasPadding&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding), "");
+
+struct NotTriviallyEqualityComparableHasFloat {
+ float i;
+ int j;
+
+ bool operator==(const NotTriviallyEqualityComparableHasFloat&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat), "");
+
+struct NotTriviallyEqualityComparableHasTailPadding {
+ int i;
+ char j;
+
+ bool operator==(const NotTriviallyEqualityComparableHasTailPadding&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding), "");
+
+struct NotTriviallyEqualityComparableBase : NotTriviallyEqualityComparableHasTailPadding {
+ char j;
+
+ bool operator==(const NotTriviallyEqualityComparableBase&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase), "");
+
+class TriviallyEqualityComparablePaddedOutBase {
+ int i;
+ char c;
+
+public:
+ bool operator==(const TriviallyEqualityComparablePaddedOutBase&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase), "");
+
+struct TriviallyEqualityComparablePaddedOut : TriviallyEqualityComparablePaddedOutBase {
+ char j[3];
+
+ bool operator==(const TriviallyEqualityComparablePaddedOut&) const = default;
+};
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut), "");
+
+struct TriviallyEqualityComparable1 {
+ char i;
+
+ bool operator==(const TriviallyEqualityComparable1&) const = default;
+};
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable1));
+
+struct TriviallyEqualityComparable2 {
+ int i;
+
+ bool operator==(const TriviallyEqualityComparable2&) const = default;
+};
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable2));
+
+struct NotTriviallyEqualityComparableTriviallyEqualityComparableBases
+ : TriviallyEqualityComparable1, TriviallyEqualityComparable2 {
+ bool operator==(const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableTriviallyEqualityComparableBases));
+
+struct NotTriviallyEqualityComparableBitfield {
+ int i : 1;
+
+ bool operator==(const NotTriviallyEqualityComparableBitfield&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));
+
+// TODO: This is trivially equality comparable
+struct NotTriviallyEqualityComparableBitfieldFilled {
+ char i : __CHAR_BIT__;
+
+ bool operator==(const NotTriviallyEqualityComparableBitfieldFilled&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));
+
+union U {
+ int i;
+
+ bool operator==(const U&) const = default;
+};
+
+struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion {
+ U u;
+
+ bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion));
+
+struct NotTriviallyEqualityComparableExplicitlyDeleted {
+ int i;
+
+ bool operator==(const NotTriviallyEqualityComparableExplicitlyDeleted&) const = delete;
+};
+
+struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct {
+ NotTriviallyEqualityComparableExplicitlyDeleted u;
+
+ bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct));
+
+#endif // __cplusplus >= 202002L
+};
+
namespace can_pass_in_regs {
struct A { };
Index: clang/lib/Sema/SemaExprCXX.cpp
===================================================================
--- clang/lib/Sema/SemaExprCXX.cpp
+++ clang/lib/Sema/SemaExprCXX.cpp
@@ -4886,8 +4886,10 @@
case UTT_IsStandardLayout:
case UTT_IsPOD:
case UTT_IsLiteral:
- // By analogy, is_trivially_relocatable imposes the same constraints.
+ // By analogy, is_trivially_relocatable and is_trivially_equality_comparable
+ // impose the same constraints.
case UTT_IsTriviallyRelocatable:
+ case UTT_IsTriviallyEqualityComparable:
case UTT_CanPassInRegs:
// Per the GCC type traits documentation, T shall be a complete type, cv void,
// or an array of unknown bound. But GCC actually imposes the same constraints
@@ -5382,6 +5384,8 @@
return RD->canPassInRegisters();
Self.Diag(KeyLoc, diag::err_builtin_pass_in_regs_non_class) << T;
return false;
+ case UTT_IsTriviallyEqualityComparable:
+ return T.isTriviallyEqualityComparableType(C);
}
}
Index: clang/lib/AST/Type.cpp
===================================================================
--- clang/lib/AST/Type.cpp
+++ clang/lib/AST/Type.cpp
@@ -25,6 +25,7 @@
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/NonTrivialTypeVisitor.h"
#include "clang/AST/PrettyPrinter.h"
+#include "clang/AST/RecordLayout.h"
#include "clang/AST/TemplateBase.h"
#include "clang/AST/TemplateName.h"
#include "clang/AST/TypeVisitor.h"
@@ -57,21 +58,21 @@
bool Qualifiers::isStrictSupersetOf(Qualifiers Other) const {
return (*this != Other) &&
- // CVR qualifiers superset
- (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) &&
- // ObjC GC qualifiers superset
- ((getObjCGCAttr() == Other.getObjCGCAttr()) ||
- (hasObjCGCAttr() && !Other.hasObjCGCAttr())) &&
- // Address space superset.
- ((getAddressSpace() == Other.getAddressSpace()) ||
- (hasAddressSpace()&& !Other.hasAddressSpace())) &&
- // Lifetime qualifier superset.
- ((getObjCLifetime() == Other.getObjCLifetime()) ||
- (hasObjCLifetime() && !Other.hasObjCLifetime()));
-}
-
-const IdentifierInfo* QualType::getBaseTypeIdentifier() const {
- const Type* ty = getTypePtr();
+ // CVR qualifiers superset
+ (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) &&
+ // ObjC GC qualifiers superset
+ ((getObjCGCAttr() == Other.getObjCGCAttr()) ||
+ (hasObjCGCAttr() && !Other.hasObjCGCAttr())) &&
+ // Address space superset.
+ ((getAddressSpace() == Other.getAddressSpace()) ||
+ (hasAddressSpace() && !Other.hasAddressSpace())) &&
+ // Lifetime qualifier superset.
+ ((getObjCLifetime() == Other.getObjCLifetime()) ||
+ (hasObjCLifetime() && !Other.hasObjCLifetime()));
+}
+
+const IdentifierInfo *QualType::getBaseTypeIdentifier() const {
+ const Type *ty = getTypePtr();
NamedDecl *ND = nullptr;
if (ty->isPointerType() || ty->isReferenceType())
return ty->getPointeeType().getBaseTypeIdentifier();
@@ -82,8 +83,9 @@
else if (ty->getTypeClass() == Type::Typedef)
ND = ty->castAs<TypedefType>()->getDecl();
else if (ty->isArrayType())
- return ty->castAsArrayTypeUnsafe()->
- getElementType().getBaseTypeIdentifier();
+ return ty->castAsArrayTypeUnsafe()
+ ->getElementType()
+ .getBaseTypeIdentifier();
if (ND)
return ND->getIdentifier();
@@ -138,9 +140,10 @@
ArrayTypeBits.SizeModifier = sm;
}
-unsigned ConstantArrayType::getNumAddressingBits(const ASTContext &Context,
- QualType ElementType,
- const llvm::APInt &NumElements) {
+unsigned
+ConstantArrayType::getNumAddressingBits(const ASTContext &Context,
+ QualType ElementType,
+ const llvm::APInt &NumElements) {
uint64_t ElementSize = Context.getTypeSizeInChars(ElementType).getQuantity();
// Fast path the common cases so we can avoid the conservative computation
@@ -164,8 +167,8 @@
// Otherwise, use APSInt to handle arbitrary sized values.
llvm::APSInt SizeExtended(NumElements, true);
unsigned SizeTypeBits = Context.getTypeSize(Context.getSizeType());
- SizeExtended = SizeExtended.extend(std::max(SizeTypeBits,
- SizeExtended.getBitWidth()) * 2);
+ SizeExtended = SizeExtended.extend(
+ std::max(SizeTypeBits, SizeExtended.getBitWidth()) * 2);
llvm::APSInt TotalSize(llvm::APInt(SizeExtended.getBitWidth(), ElementSize));
TotalSize *= SizeExtended;
@@ -204,15 +207,13 @@
Expr *e, ArraySizeModifier sm,
unsigned tq,
SourceRange brackets)
- : ArrayType(DependentSizedArray, et, can, sm, tq, e),
- Context(Context), SizeExpr((Stmt*) e), Brackets(brackets) {}
+ : ArrayType(DependentSizedArray, et, can, sm, tq, e), Context(Context),
+ SizeExpr((Stmt *)e), Brackets(brackets) {}
void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID,
- const ASTContext &Context,
- QualType ET,
+ const ASTContext &Context, QualType ET,
ArraySizeModifier SizeMod,
- unsigned TypeQuals,
- Expr *E) {
+ unsigned TypeQuals, Expr *E) {
ID.AddPointer(ET.getAsOpaquePtr());
ID.AddInteger(SizeMod);
ID.AddInteger(TypeQuals);
@@ -253,10 +254,10 @@
Context(Context), SizeExpr(SizeExpr), ElementType(ElementType), loc(loc) {
}
-void
-DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID,
- const ASTContext &Context,
- QualType ElementType, Expr *SizeExpr) {
+void DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID,
+ const ASTContext &Context,
+ QualType ElementType,
+ Expr *SizeExpr) {
ID.AddPointer(ElementType.getAsOpaquePtr());
SizeExpr->Profile(ID, Context, true);
}
@@ -378,7 +379,8 @@
// If this is a typedef for an array type, strip the typedef off without
// losing all typedef information.
return cast<ArrayType>(getUnqualifiedDesugaredType())
- ->getElementType().getTypePtr();
+ ->getElementType()
+ .getTypePtr();
}
/// getDesugaredType - Return the specified type with any "sugar" removed from
@@ -402,8 +404,8 @@
// Check that no type class is polymorphic. LLVM style RTTI should be used
// instead. If absolutely needed an exception can still be added here by
// defining the appropriate macro (but please don't do this).
-#define TYPE(CLASS, BASE) \
- static_assert(!std::is_polymorphic<CLASS##Type>::value, \
+#define TYPE(CLASS, BASE) \
+ static_assert(!std::is_polymorphic<CLASS##Type>::value, \
#CLASS "Type should not be polymorphic!");
#include "clang/AST/TypeNodes.inc"
@@ -422,11 +424,12 @@
QualType Type::getLocallyUnqualifiedSingleStepDesugaredType() const {
switch (getTypeClass()) {
#define ABSTRACT_TYPE(Class, Parent)
-#define TYPE(Class, Parent) \
- case Type::Class: { \
- const auto *ty = cast<Class##Type>(this); \
- if (!ty->isSugared()) return QualType(ty, 0); \
- return ty->desugar(); \
+#define TYPE(Class, Parent) \
+ case Type::Class: { \
+ const auto *ty = cast<Class##Type>(this); \
+ if (!ty->isSugared()) \
+ return QualType(ty, 0); \
+ return ty->desugar(); \
}
#include "clang/AST/TypeNodes.inc"
}
@@ -441,14 +444,14 @@
const Type *CurTy = Qs.strip(Cur);
switch (CurTy->getTypeClass()) {
#define ABSTRACT_TYPE(Class, Parent)
-#define TYPE(Class, Parent) \
- case Type::Class: { \
- const auto *Ty = cast<Class##Type>(CurTy); \
- if (!Ty->isSugared()) \
- return SplitQualType(Ty, Qs); \
- Cur = Ty->desugar(); \
- break; \
- }
+#define TYPE(Class, Parent) \
+ case Type::Class: { \
+ const auto *Ty = cast<Class##Type>(CurTy); \
+ if (!Ty->isSugared()) \
+ return SplitQualType(Ty, Qs); \
+ Cur = Ty->desugar(); \
+ break; \
+ }
#include "clang/AST/TypeNodes.inc"
}
}
@@ -470,13 +473,14 @@
// sugared.
switch (split.Ty->getTypeClass()) {
#define ABSTRACT_TYPE(Class, Parent)
-#define TYPE(Class, Parent) \
- case Type::Class: { \
- const auto *ty = cast<Class##Type>(split.Ty); \
- if (!ty->isSugared()) goto done; \
- next = ty->desugar(); \
- break; \
- }
+#define TYPE(Class, Parent) \
+ case Type::Class: { \
+ const auto *ty = cast<Class##Type>(split.Ty); \
+ if (!ty->isSugared()) \
+ goto done; \
+ next = ty->desugar(); \
+ break; \
+ }
#include "clang/AST/TypeNodes.inc"
}
@@ -489,7 +493,7 @@
}
}
- done:
+done:
return SplitQualType(lastTypeWithQuals, quals);
}
@@ -503,19 +507,20 @@
/// This will check for a T (which should be a Type which can act as
/// sugar, such as a TypedefType) by removing any existing sugar until it
/// reaches a T or a non-sugared type.
-template<typename T> static const T *getAsSugar(const Type *Cur) {
+template <typename T> static const T *getAsSugar(const Type *Cur) {
while (true) {
if (const auto *Sugar = dyn_cast<T>(Cur))
return Sugar;
switch (Cur->getTypeClass()) {
#define ABSTRACT_TYPE(Class, Parent)
-#define TYPE(Class, Parent) \
- case Type::Class: { \
- const auto *Ty = cast<Class##Type>(Cur); \
- if (!Ty->isSugared()) return 0; \
- Cur = Ty->desugar().getTypePtr(); \
- break; \
- }
+#define TYPE(Class, Parent) \
+ case Type::Class: { \
+ const auto *Ty = cast<Class##Type>(Cur); \
+ if (!Ty->isSugared()) \
+ return 0; \
+ Cur = Ty->desugar().getTypePtr(); \
+ break; \
+ }
#include "clang/AST/TypeNodes.inc"
}
}
@@ -546,13 +551,14 @@
while (true) {
switch (Cur->getTypeClass()) {
#define ABSTRACT_TYPE(Class, Parent)
-#define TYPE(Class, Parent) \
- case Class: { \
- const auto *Ty = cast<Class##Type>(Cur); \
- if (!Ty->isSugared()) return Cur; \
- Cur = Ty->desugar().getTypePtr(); \
- break; \
- }
+#define TYPE(Class, Parent) \
+ case Class: { \
+ const auto *Ty = cast<Class##Type>(Cur); \
+ if (!Ty->isSugared()) \
+ return Cur; \
+ Cur = Ty->desugar().getTypePtr(); \
+ break; \
+ }
#include "clang/AST/TypeNodes.inc"
}
}
@@ -702,8 +708,9 @@
return false;
// Figure out the type bound for the __kindof type.
- bound = OPT->getObjectType()->stripObjCKindOfTypeAndQuals(ctx)
- ->getAs<ObjCObjectType>();
+ bound = OPT->getObjectType()
+ ->stripObjCKindOfTypeAndQuals(ctx)
+ ->getAs<ObjCObjectType>();
return true;
}
@@ -806,8 +813,8 @@
return false;
}
-QualType ObjCObjectType::stripObjCKindOfTypeAndQuals(
- const ASTContext &ctx) const {
+QualType
+ObjCObjectType::stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const {
if (!isKindOfType() && qual_empty())
return QualType(this, 0);
@@ -817,11 +824,11 @@
if (const auto *baseObj = splitBaseType.Ty->getAs<ObjCObjectType>())
baseType = baseObj->stripObjCKindOfTypeAndQuals(ctx);
- return ctx.getObjCObjectType(ctx.getQualifiedType(baseType,
- splitBaseType.Quals),
- getTypeArgsAsWritten(),
- /*protocols=*/{},
- /*isKindOf=*/false);
+ return ctx.getObjCObjectType(
+ ctx.getQualifiedType(baseType, splitBaseType.Quals),
+ getTypeArgsAsWritten(),
+ /*protocols=*/{},
+ /*isKindOf=*/false);
}
ObjCInterfaceDecl *ObjCInterfaceType::getDecl() const {
@@ -832,7 +839,7 @@
}
const ObjCObjectPointerType *ObjCObjectPointerType::stripObjCKindOfTypeAndQuals(
- const ASTContext &ctx) const {
+ const ASTContext &ctx) const {
if (!isKindOfType() && qual_empty())
return this;
@@ -868,22 +875,22 @@
// None of the clients of this transformation can occur where
// there are dependent types, so skip dependent types.
#define TYPE(Class, Base)
-#define DEPENDENT_TYPE(Class, Base) \
+#define DEPENDENT_TYPE(Class, Base) \
QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
#include "clang/AST/TypeNodes.inc"
-#define TRIVIAL_TYPE_CLASS(Class) \
+#define TRIVIAL_TYPE_CLASS(Class) \
QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
-#define SUGARED_TYPE_CLASS(Class) \
- QualType Visit##Class##Type(const Class##Type *T) { \
- if (!T->isSugared()) \
- return QualType(T, 0); \
- QualType desugaredType = recurse(T->desugar()); \
- if (desugaredType.isNull()) \
- return {}; \
- if (desugaredType.getAsOpaquePtr() == T->desugar().getAsOpaquePtr()) \
- return QualType(T, 0); \
- return desugaredType; \
+#define SUGARED_TYPE_CLASS(Class) \
+ QualType Visit##Class##Type(const Class##Type *T) { \
+ if (!T->isSugared()) \
+ return QualType(T, 0); \
+ QualType desugaredType = recurse(T->desugar()); \
+ if (desugaredType.isNull()) \
+ return {}; \
+ if (desugaredType.getAsOpaquePtr() == T->desugar().getAsOpaquePtr()) \
+ return QualType(T, 0); \
+ return desugaredType; \
}
TRIVIAL_TYPE_CLASS(Builtin)
@@ -926,8 +933,8 @@
if (pointeeType.isNull())
return {};
- if (pointeeType.getAsOpaquePtr()
- == T->getPointeeTypeAsWritten().getAsOpaquePtr())
+ if (pointeeType.getAsOpaquePtr() ==
+ T->getPointeeTypeAsWritten().getAsOpaquePtr())
return QualType(T, 0);
return Ctx.getLValueReferenceType(pointeeType, T->isSpelledAsLValue());
@@ -938,8 +945,8 @@
if (pointeeType.isNull())
return {};
- if (pointeeType.getAsOpaquePtr()
- == T->getPointeeTypeAsWritten().getAsOpaquePtr())
+ if (pointeeType.getAsOpaquePtr() ==
+ T->getPointeeTypeAsWritten().getAsOpaquePtr())
return QualType(T, 0);
return Ctx.getRValueReferenceType(pointeeType);
@@ -977,10 +984,9 @@
if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
return QualType(T, 0);
- return Ctx.getVariableArrayType(elementType, T->getSizeExpr(),
- T->getSizeModifier(),
- T->getIndexTypeCVRQualifiers(),
- T->getBracketsRange());
+ return Ctx.getVariableArrayType(
+ elementType, T->getSizeExpr(), T->getSizeModifier(),
+ T->getIndexTypeCVRQualifiers(), T->getBracketsRange());
}
QualType VisitIncompleteArrayType(const IncompleteArrayType *T) {
@@ -1112,8 +1118,8 @@
if (adjustedType.isNull())
return {};
- if (originalType.getAsOpaquePtr()
- == T->getOriginalType().getAsOpaquePtr() &&
+ if (originalType.getAsOpaquePtr() ==
+ T->getOriginalType().getAsOpaquePtr() &&
adjustedType.getAsOpaquePtr() == T->getAdjustedType().getAsOpaquePtr())
return QualType(T, 0);
@@ -1125,8 +1131,7 @@
if (originalType.isNull())
return {};
- if (originalType.getAsOpaquePtr()
- == T->getOriginalType().getAsOpaquePtr())
+ if (originalType.getAsOpaquePtr() == T->getOriginalType().getAsOpaquePtr())
return QualType(T, 0);
return Ctx.getDecayedType(originalType);
@@ -1151,10 +1156,10 @@
if (equivalentType.isNull())
return {};
- if (modifiedType.getAsOpaquePtr()
- == T->getModifiedType().getAsOpaquePtr() &&
- equivalentType.getAsOpaquePtr()
- == T->getEquivalentType().getAsOpaquePtr())
+ if (modifiedType.getAsOpaquePtr() ==
+ T->getModifiedType().getAsOpaquePtr() &&
+ equivalentType.getAsOpaquePtr() ==
+ T->getEquivalentType().getAsOpaquePtr())
return QualType(T, 0);
return Ctx.getAttributedType(T->getAttrKind(), modifiedType,
@@ -1166,8 +1171,8 @@
if (replacementType.isNull())
return {};
- if (replacementType.getAsOpaquePtr()
- == T->getReplacementType().getAsOpaquePtr())
+ if (replacementType.getAsOpaquePtr() ==
+ T->getReplacementType().getAsOpaquePtr())
return QualType(T, 0);
return Ctx.getSubstTemplateTypeParmType(replacementType,
@@ -1186,13 +1191,11 @@
if (deducedType.isNull())
return {};
- if (deducedType.getAsOpaquePtr()
- == T->getDeducedType().getAsOpaquePtr())
+ if (deducedType.getAsOpaquePtr() == T->getDeducedType().getAsOpaquePtr())
return QualType(T, 0);
- return Ctx.getAutoType(deducedType, T->getKeyword(),
- T->isDependentType(), /*IsPack=*/false,
- T->getTypeConstraintConcept(),
+ return Ctx.getAutoType(deducedType, T->getKeyword(), T->isDependentType(),
+ /*IsPack=*/false, T->getTypeConstraintConcept(),
T->getTypeConstraintArguments());
}
@@ -1232,8 +1235,7 @@
if (pointeeType.isNull())
return {};
- if (pointeeType.getAsOpaquePtr()
- == T->getPointeeType().getAsOpaquePtr())
+ if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
return QualType(T, 0);
return Ctx.getObjCObjectPointerType(pointeeType);
@@ -1244,8 +1246,7 @@
if (valueType.isNull())
return {};
- if (valueType.getAsOpaquePtr()
- == T->getValueType().getAsOpaquePtr())
+ if (valueType.getAsOpaquePtr() == T->getValueType().getAsOpaquePtr())
return QualType(T, 0);
return Ctx.getAtomicType(valueType);
@@ -1282,7 +1283,7 @@
protocolsVec.append(OTPTy->qual_begin(), OTPTy->qual_end());
ArrayRef<ObjCProtocolDecl *> protocolsToApply = protocolsVec;
return Ctx.applyObjCProtocolQualifiers(
- argType, protocolsToApply, hasError, true/*allowOnPointerType*/);
+ argType, protocolsToApply, hasError, true /*allowOnPointerType*/);
}
switch (SubstContext) {
@@ -1320,7 +1321,7 @@
// If we have a function type, update the substitution context
// appropriately.
- //Substitute result type.
+ // Substitute result type.
QualType returnType = funcType->getReturnType().substObjCTypeArgs(
Ctx, TypeArgs, ObjCSubstitutionContext::Result);
if (returnType.isNull())
@@ -1578,14 +1579,14 @@
} else if (getAs<BlockPointerType>()) {
ASTContext &ctx = dc->getParentASTContext();
objectType = ctx.getObjCObjectType(ctx.ObjCBuiltinIdTy, {}, {})
- ->castAs<ObjCObjectType>();
+ ->castAs<ObjCObjectType>();
} else {
objectType = getAs<ObjCObjectType>();
}
/// Extract the class from the receiver object type.
- ObjCInterfaceDecl *curClassDecl = objectType ? objectType->getInterface()
- : nullptr;
+ ObjCInterfaceDecl *curClassDecl =
+ objectType ? objectType->getInterface() : nullptr;
if (!curClassDecl) {
// If we don't have a context type (e.g., this is "id" or some
// variant thereof), substitute the bounds.
@@ -1656,7 +1657,7 @@
ObjCTypeParamList *superClassTypeParams = superClassDecl->getTypeParamList();
if (!superClassTypeParams) {
CachedSuperClassType.setPointerAndInt(
- superClassType->castAs<ObjCObjectType>(), true);
+ superClassType->castAs<ObjCObjectType>(), true);
return;
}
@@ -1671,19 +1672,18 @@
ObjCTypeParamList *typeParams = classDecl->getTypeParamList();
if (!typeParams) {
CachedSuperClassType.setPointerAndInt(
- superClassType->castAs<ObjCObjectType>(), true);
+ superClassType->castAs<ObjCObjectType>(), true);
return;
}
// If the subclass type isn't specialized, return the unspecialized
// superclass.
if (isUnspecialized()) {
- QualType unspecializedSuper
- = classDecl->getASTContext().getObjCInterfaceType(
- superClassObjTy->getInterface());
+ QualType unspecializedSuper =
+ classDecl->getASTContext().getObjCInterfaceType(
+ superClassObjTy->getInterface());
CachedSuperClassType.setPointerAndInt(
- unspecializedSuper->castAs<ObjCObjectType>(),
- true);
+ unspecializedSuper->castAs<ObjCObjectType>(), true);
return;
}
@@ -1691,16 +1691,18 @@
ArrayRef<QualType> typeArgs = getTypeArgs();
assert(typeArgs.size() == typeParams->size());
CachedSuperClassType.setPointerAndInt(
- superClassType.substObjCTypeArgs(classDecl->getASTContext(), typeArgs,
- ObjCSubstitutionContext::Superclass)
- ->castAs<ObjCObjectType>(),
- true);
+ superClassType
+ .substObjCTypeArgs(classDecl->getASTContext(), typeArgs,
+ ObjCSubstitutionContext::Superclass)
+ ->castAs<ObjCObjectType>(),
+ true);
}
const ObjCInterfaceType *ObjCObjectPointerType::getInterfaceType() const {
if (auto interfaceDecl = getObjectType()->getInterface()) {
- return interfaceDecl->getASTContext().getObjCInterfaceType(interfaceDecl)
- ->castAs<ObjCInterfaceType>();
+ return interfaceDecl->getASTContext()
+ .getObjCInterfaceType(interfaceDecl)
+ ->castAs<ObjCInterfaceType>();
}
return nullptr;
@@ -1809,103 +1811,100 @@
namespace {
- class GetContainedDeducedTypeVisitor :
- public TypeVisitor<GetContainedDeducedTypeVisitor, Type*> {
- bool Syntactic;
+class GetContainedDeducedTypeVisitor
+ : public TypeVisitor<GetContainedDeducedTypeVisitor, Type *> {
+ bool Syntactic;
- public:
- GetContainedDeducedTypeVisitor(bool Syntactic = false)
- : Syntactic(Syntactic) {}
+public:
+ GetContainedDeducedTypeVisitor(bool Syntactic = false)
+ : Syntactic(Syntactic) {}
- using TypeVisitor<GetContainedDeducedTypeVisitor, Type*>::Visit;
+ using TypeVisitor<GetContainedDeducedTypeVisitor, Type *>::Visit;
- Type *Visit(QualType T) {
- if (T.isNull())
- return nullptr;
- return Visit(T.getTypePtr());
- }
+ Type *Visit(QualType T) {
+ if (T.isNull())
+ return nullptr;
+ return Visit(T.getTypePtr());
+ }
- // The deduced type itself.
- Type *VisitDeducedType(const DeducedType *AT) {
- return const_cast<DeducedType*>(AT);
- }
+ // The deduced type itself.
+ Type *VisitDeducedType(const DeducedType *AT) {
+ return const_cast<DeducedType *>(AT);
+ }
- // Only these types can contain the desired 'auto' type.
- Type *VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
- return Visit(T->getReplacementType());
- }
+ // Only these types can contain the desired 'auto' type.
+ Type *VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
+ return Visit(T->getReplacementType());
+ }
- Type *VisitElaboratedType(const ElaboratedType *T) {
- return Visit(T->getNamedType());
- }
+ Type *VisitElaboratedType(const ElaboratedType *T) {
+ return Visit(T->getNamedType());
+ }
- Type *VisitPointerType(const PointerType *T) {
- return Visit(T->getPointeeType());
- }
+ Type *VisitPointerType(const PointerType *T) {
+ return Visit(T->getPointeeType());
+ }
- Type *VisitBlockPointerType(const BlockPointerType *T) {
- return Visit(T->getPointeeType());
- }
+ Type *VisitBlockPointerType(const BlockPointerType *T) {
+ return Visit(T->getPointeeType());
+ }
- Type *VisitReferenceType(const ReferenceType *T) {
- return Visit(T->getPointeeTypeAsWritten());
- }
+ Type *VisitReferenceType(const ReferenceType *T) {
+ return Visit(T->getPointeeTypeAsWritten());
+ }
- Type *VisitMemberPointerType(const MemberPointerType *T) {
- return Visit(T->getPointeeType());
- }
+ Type *VisitMemberPointerType(const MemberPointerType *T) {
+ return Visit(T->getPointeeType());
+ }
- Type *VisitArrayType(const ArrayType *T) {
- return Visit(T->getElementType());
- }
+ Type *VisitArrayType(const ArrayType *T) {
+ return Visit(T->getElementType());
+ }
- Type *VisitDependentSizedExtVectorType(
- const DependentSizedExtVectorType *T) {
- return Visit(T->getElementType());
- }
+ Type *VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) {
+ return Visit(T->getElementType());
+ }
- Type *VisitVectorType(const VectorType *T) {
- return Visit(T->getElementType());
- }
+ Type *VisitVectorType(const VectorType *T) {
+ return Visit(T->getElementType());
+ }
- Type *VisitDependentSizedMatrixType(const DependentSizedMatrixType *T) {
- return Visit(T->getElementType());
- }
+ Type *VisitDependentSizedMatrixType(const DependentSizedMatrixType *T) {
+ return Visit(T->getElementType());
+ }
- Type *VisitConstantMatrixType(const ConstantMatrixType *T) {
- return Visit(T->getElementType());
- }
+ Type *VisitConstantMatrixType(const ConstantMatrixType *T) {
+ return Visit(T->getElementType());
+ }
- Type *VisitFunctionProtoType(const FunctionProtoType *T) {
- if (Syntactic && T->hasTrailingReturn())
- return const_cast<FunctionProtoType*>(T);
- return VisitFunctionType(T);
- }
+ Type *VisitFunctionProtoType(const FunctionProtoType *T) {
+ if (Syntactic && T->hasTrailingReturn())
+ return const_cast<FunctionProtoType *>(T);
+ return VisitFunctionType(T);
+ }
- Type *VisitFunctionType(const FunctionType *T) {
- return Visit(T->getReturnType());
- }
+ Type *VisitFunctionType(const FunctionType *T) {
+ return Visit(T->getReturnType());
+ }
- Type *VisitParenType(const ParenType *T) {
- return Visit(T->getInnerType());
- }
+ Type *VisitParenType(const ParenType *T) { return Visit(T->getInnerType()); }
- Type *VisitAttributedType(const AttributedType *T) {
- return Visit(T->getModifiedType());
- }
+ Type *VisitAttributedType(const AttributedType *T) {
+ return Visit(T->getModifiedType());
+ }
- Type *VisitMacroQualifiedType(const MacroQualifiedType *T) {
- return Visit(T->getUnderlyingType());
- }
+ Type *VisitMacroQualifiedType(const MacroQualifiedType *T) {
+ return Visit(T->getUnderlyingType());
+ }
- Type *VisitAdjustedType(const AdjustedType *T) {
- return Visit(T->getOriginalType());
- }
+ Type *VisitAdjustedType(const AdjustedType *T) {
+ return Visit(T->getOriginalType());
+ }
- Type *VisitPackExpansionType(const PackExpansionType *T) {
- return Visit(T->getPattern());
- }
- };
+ Type *VisitPackExpansionType(const PackExpansionType *T) {
+ return Visit(T->getPattern());
+ }
+};
} // namespace
@@ -2020,9 +2019,11 @@
/// types.
bool Type::isAnyCharacterType() const {
const auto *BT = dyn_cast<BuiltinType>(CanonicalType);
- if (!BT) return false;
+ if (!BT)
+ return false;
switch (BT->getKind()) {
- default: return false;
+ default:
+ return false;
case BuiltinType::Char_U:
case BuiltinType::UChar:
case BuiltinType::WChar_U:
@@ -2113,7 +2114,7 @@
bool Type::isUnsignedIntegerOrEnumerationType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
return BT->getKind() >= BuiltinType::Bool &&
- BT->getKind() <= BuiltinType::UInt128;
+ BT->getKind() <= BuiltinType::UInt128;
}
if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
@@ -2170,7 +2171,7 @@
return BT->getKind() >= BuiltinType::Bool &&
BT->getKind() <= BuiltinType::Ibm128;
if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
- return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
+ return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
return isBitIntType();
}
@@ -2195,11 +2196,16 @@
const Type *T = CanonicalType.getTypePtr();
if (const auto *BT = dyn_cast<BuiltinType>(T)) {
- if (BT->getKind() == BuiltinType::Bool) return STK_Bool;
- if (BT->getKind() == BuiltinType::NullPtr) return STK_CPointer;
- if (BT->isInteger()) return STK_Integral;
- if (BT->isFloatingPoint()) return STK_Floating;
- if (BT->isFixedPointType()) return STK_FixedPoint;
+ if (BT->getKind() == BuiltinType::Bool)
+ return STK_Bool;
+ if (BT->getKind() == BuiltinType::NullPtr)
+ return STK_CPointer;
+ if (BT->isInteger())
+ return STK_Integral;
+ if (BT->isFloatingPoint())
+ return STK_Floating;
+ if (BT->isFixedPointType())
+ return STK_FixedPoint;
llvm_unreachable("unknown scalar builtin type");
} else if (isa<PointerType>(T)) {
return STK_CPointer;
@@ -2261,7 +2267,8 @@
*Def = nullptr;
switch (CanonicalType->getTypeClass()) {
- default: return false;
+ default:
+ return false;
case Builtin:
// Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never
// be completed.
@@ -2286,8 +2293,9 @@
// (C++ [dcl.array]p1).
// We don't handle dependent-sized arrays (dependent types are never treated
// as incomplete).
- return cast<ArrayType>(CanonicalType)->getElementType()
- ->isIncompleteType(Def);
+ return cast<ArrayType>(CanonicalType)
+ ->getElementType()
+ ->isIncompleteType(Def);
case IncompleteArray:
// An array of unknown size is an incomplete type (C99 6.2.5p22).
return true;
@@ -2314,12 +2322,13 @@
return true;
}
case ObjCObject:
- return cast<ObjCObjectType>(CanonicalType)->getBaseType()
- ->isIncompleteType(Def);
+ return cast<ObjCObjectType>(CanonicalType)
+ ->getBaseType()
+ ->isIncompleteType(Def);
case ObjCInterface: {
// ObjC interfaces are incomplete if they are @class, not @interface.
- ObjCInterfaceDecl *Interface
- = cast<ObjCInterfaceType>(CanonicalType)->getDecl();
+ ObjCInterfaceDecl *Interface =
+ cast<ObjCInterfaceType>(CanonicalType)->getDecl();
if (Def)
*Def = Interface;
return !Interface->hasDefinition();
@@ -2452,7 +2461,8 @@
QualType CanonicalType = getTypePtr()->CanonicalType;
switch (CanonicalType->getTypeClass()) {
// Everything not explicitly mentioned is not POD.
- default: return false;
+ default:
+ return false;
case Type::VariableArray:
case Type::ConstantArray:
// IncompleteArray is handled above.
@@ -2565,7 +2575,8 @@
if (const auto *RT = CanonicalType->getAs<RecordType>()) {
if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
- if (!ClassDecl->isTriviallyCopyable()) return false;
+ if (!ClassDecl->isTriviallyCopyable())
+ return false;
}
return true;
@@ -2594,13 +2605,55 @@
}
}
+static bool HasDefaultedEqualityComparison(const CXXRecordDecl *Decl) {
+ if (Decl->isUnion())
+ return false;
+
+ if (llvm::none_of(Decl->methods(), [](const CXXMethodDecl *MemberFunction) {
+ return MemberFunction->isOverloadedOperator() &&
+ MemberFunction->getOverloadedOperator() ==
+ OverloadedOperatorKind::OO_EqualEqual &&
+ MemberFunction->isDefaulted();
+ }))
+ return false;
+
+ return llvm::all_of(Decl->bases(),
+ [](const CXXBaseSpecifier &BS) {
+ if (!BS.getType()->isRecordType())
+ return true;
+ return HasDefaultedEqualityComparison(
+ BS.getType()->getAsCXXRecordDecl());
+ }) &&
+ llvm::all_of(Decl->fields(), [](const FieldDecl *FD) {
+ if (!FD->getType()->isRecordType())
+ return true;
+ return HasDefaultedEqualityComparison(
+ FD->getType()->getAsCXXRecordDecl());
+ });
+}
+
+bool QualType::isTriviallyEqualityComparableType(
+ const ASTContext &Context) const {
+ QualType CanonicalType = getCanonicalType();
+ if (CanonicalType->isIncompleteType() || CanonicalType->isDependentType())
+ return false;
+
+ if (const auto *RecordDecl = CanonicalType->getAsCXXRecordDecl()) {
+ if (!HasDefaultedEqualityComparison(CanonicalType->getAsCXXRecordDecl()))
+ return false;
+ }
+
+ return Context.hasUniqueObjectRepresentations(CanonicalType);
+}
+
bool QualType::isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const {
return !Context.getLangOpts().ObjCAutoRefCount &&
Context.getLangOpts().ObjCWeak &&
getObjCLifetime() != Qualifiers::OCL_Weak;
}
-bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD) {
+bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion(
+ const RecordDecl *RD) {
return RD->hasNonTrivialToPrimitiveDefaultInitializeCUnion();
}
@@ -2749,7 +2802,8 @@
return false;
// As an extension, Clang treats vector types as Scalar types.
- if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
+ if (BaseTy->isScalarType() || BaseTy->isVectorType())
+ return true;
if (const auto *RT = BaseTy->getAs<RecordType>()) {
if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
if (!ClassDecl->isStandardLayout())
@@ -2791,17 +2845,20 @@
return false;
// As an extension, Clang treats vector types as Scalar types.
- if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
+ if (BaseTy->isScalarType() || BaseTy->isVectorType())
+ return true;
if (const auto *RT = BaseTy->getAs<RecordType>()) {
if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
// C++11 [class]p10:
// A POD struct is a non-union class that is both a trivial class [...]
- if (!ClassDecl->isTrivial()) return false;
+ if (!ClassDecl->isTrivial())
+ return false;
// C++11 [class]p10:
// A POD struct is a non-union class that is both a trivial class and
// a standard-layout class [...]
- if (!ClassDecl->isStandardLayout()) return false;
+ if (!ClassDecl->isStandardLayout())
+ return false;
// C++11 [class]p10:
// A POD struct is a non-union class that is both a trivial class and
@@ -2874,24 +2931,35 @@
ElaboratedTypeKeyword
TypeWithKeyword::getKeywordForTypeSpec(unsigned TypeSpec) {
switch (TypeSpec) {
- default: return ETK_None;
- case TST_typename: return ETK_Typename;
- case TST_class: return ETK_Class;
- case TST_struct: return ETK_Struct;
- case TST_interface: return ETK_Interface;
- case TST_union: return ETK_Union;
- case TST_enum: return ETK_Enum;
- }
-}
-
-TagTypeKind
-TypeWithKeyword::getTagTypeKindForTypeSpec(unsigned TypeSpec) {
- switch(TypeSpec) {
- case TST_class: return TTK_Class;
- case TST_struct: return TTK_Struct;
- case TST_interface: return TTK_Interface;
- case TST_union: return TTK_Union;
- case TST_enum: return TTK_Enum;
+ default:
+ return ETK_None;
+ case TST_typename:
+ return ETK_Typename;
+ case TST_class:
+ return ETK_Class;
+ case TST_struct:
+ return ETK_Struct;
+ case TST_interface:
+ return ETK_Interface;
+ case TST_union:
+ return ETK_Union;
+ case TST_enum:
+ return ETK_Enum;
+ }
+}
+
+TagTypeKind TypeWithKeyword::getTagTypeKindForTypeSpec(unsigned TypeSpec) {
+ switch (TypeSpec) {
+ case TST_class:
+ return TTK_Class;
+ case TST_struct:
+ return TTK_Struct;
+ case TST_interface:
+ return TTK_Interface;
+ case TST_union:
+ return TTK_Union;
+ case TST_enum:
+ return TTK_Enum;
}
llvm_unreachable("Type specifier is not a tag type kind.");
@@ -2900,11 +2968,16 @@
ElaboratedTypeKeyword
TypeWithKeyword::getKeywordForTagTypeKind(TagTypeKind Kind) {
switch (Kind) {
- case TTK_Class: return ETK_Class;
- case TTK_Struct: return ETK_Struct;
- case TTK_Interface: return ETK_Interface;
- case TTK_Union: return ETK_Union;
- case TTK_Enum: return ETK_Enum;
+ case TTK_Class:
+ return ETK_Class;
+ case TTK_Struct:
+ return ETK_Struct;
+ case TTK_Interface:
+ return ETK_Interface;
+ case TTK_Union:
+ return ETK_Union;
+ case TTK_Enum:
+ return ETK_Enum;
}
llvm_unreachable("Unknown tag type kind.");
}
@@ -2912,11 +2985,16 @@
TagTypeKind
TypeWithKeyword::getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword) {
switch (Keyword) {
- case ETK_Class: return TTK_Class;
- case ETK_Struct: return TTK_Struct;
- case ETK_Interface: return TTK_Interface;
- case ETK_Union: return TTK_Union;
- case ETK_Enum: return TTK_Enum;
+ case ETK_Class:
+ return TTK_Class;
+ case ETK_Struct:
+ return TTK_Struct;
+ case ETK_Interface:
+ return TTK_Interface;
+ case ETK_Union:
+ return TTK_Union;
+ case ETK_Enum:
+ return TTK_Enum;
case ETK_None: // Fall through.
case ETK_Typename:
llvm_unreachable("Elaborated type keyword is not a tag type kind.");
@@ -2924,8 +3002,7 @@
llvm_unreachable("Unknown elaborated type keyword.");
}
-bool
-TypeWithKeyword::KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword) {
+bool TypeWithKeyword::KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword) {
switch (Keyword) {
case ETK_None:
case ETK_Typename:
@@ -2942,13 +3019,20 @@
StringRef TypeWithKeyword::getKeywordName(ElaboratedTypeKeyword Keyword) {
switch (Keyword) {
- case ETK_None: return {};
- case ETK_Typename: return "typename";
- case ETK_Class: return "class";
- case ETK_Struct: return "struct";
- case ETK_Interface: return "__interface";
- case ETK_Union: return "union";
- case ETK_Enum: return "enum";
+ case ETK_None:
+ return {};
+ case ETK_Typename:
+ return "typename";
+ case ETK_Class:
+ return "class";
+ case ETK_Struct:
+ return "struct";
+ case ETK_Interface:
+ return "__interface";
+ case ETK_Union:
+ return "union";
+ case ETK_Enum:
+ return "enum";
}
llvm_unreachable("Unknown elaborated type keyword.");
@@ -2974,13 +3058,10 @@
}
}
-void
-DependentTemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
- const ASTContext &Context,
- ElaboratedTypeKeyword Keyword,
- NestedNameSpecifier *Qualifier,
- const IdentifierInfo *Name,
- ArrayRef<TemplateArgument> Args) {
+void DependentTemplateSpecializationType::Profile(
+ llvm::FoldingSetNodeID &ID, const ASTContext &Context,
+ ElaboratedTypeKeyword Keyword, NestedNameSpecifier *Qualifier,
+ const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args) {
ID.AddInteger(Keyword);
ID.AddPointer(Qualifier);
ID.AddPointer(Name);
@@ -3006,7 +3087,9 @@
const char *Type::getTypeClassName() const {
switch (TypeBits.TC) {
#define ABSTRACT_TYPE(Derived, Base)
-#define TYPE(Derived, Base) case Derived: return #Derived;
+#define TYPE(Derived, Base) \
+ case Derived: \
+ return #Derived;
#include "clang/AST/TypeNodes.inc"
}
@@ -3142,8 +3225,8 @@
return "Class";
case ObjCSel:
return "SEL";
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
- case Id: \
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case Id: \
return "__" #Access " " #ImgType "_t";
#include "clang/Basic/OpenCLImageTypes.def"
case OCLSampler:
@@ -3164,16 +3247,16 @@
return "<OpenMP array shaping type>";
case OMPIterator:
return "<OpenMP iterator type>";
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
- case Id: \
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
+ case Id: \
return #ExtType;
#include "clang/Basic/OpenCLExtensionTypes.def"
-#define SVE_TYPE(Name, Id, SingletonId) \
- case Id: \
+#define SVE_TYPE(Name, Id, SingletonId) \
+ case Id: \
return Name;
#include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
- case Id: \
+#define PPC_VECTOR_TYPE(Name, Id, Size) \
+ case Id: \
return #Name;
#include "clang/Basic/PPCTypes.def"
#define RVV_TYPE(Name, Id, SingletonId) \
@@ -3214,27 +3297,48 @@
StringRef FunctionType::getNameForCallConv(CallingConv CC) {
switch (CC) {
- case CC_C: return "cdecl";
- case CC_X86StdCall: return "stdcall";
- case CC_X86FastCall: return "fastcall";
- case CC_X86ThisCall: return "thiscall";
- case CC_X86Pascal: return "pascal";
- case CC_X86VectorCall: return "vectorcall";
- case CC_Win64: return "ms_abi";
- case CC_X86_64SysV: return "sysv_abi";
- case CC_X86RegCall : return "regcall";
- case CC_AAPCS: return "aapcs";
- case CC_AAPCS_VFP: return "aapcs-vfp";
- case CC_AArch64VectorCall: return "aarch64_vector_pcs";
- case CC_AArch64SVEPCS: return "aarch64_sve_pcs";
- case CC_AMDGPUKernelCall: return "amdgpu_kernel";
- case CC_IntelOclBicc: return "intel_ocl_bicc";
- case CC_SpirFunction: return "spir_function";
- case CC_OpenCLKernel: return "opencl_kernel";
- case CC_Swift: return "swiftcall";
- case CC_SwiftAsync: return "swiftasynccall";
- case CC_PreserveMost: return "preserve_most";
- case CC_PreserveAll: return "preserve_all";
+ case CC_C:
+ return "cdecl";
+ case CC_X86StdCall:
+ return "stdcall";
+ case CC_X86FastCall:
+ return "fastcall";
+ case CC_X86ThisCall:
+ return "thiscall";
+ case CC_X86Pascal:
+ return "pascal";
+ case CC_X86VectorCall:
+ return "vectorcall";
+ case CC_Win64:
+ return "ms_abi";
+ case CC_X86_64SysV:
+ return "sysv_abi";
+ case CC_X86RegCall:
+ return "regcall";
+ case CC_AAPCS:
+ return "aapcs";
+ case CC_AAPCS_VFP:
+ return "aapcs-vfp";
+ case CC_AArch64VectorCall:
+ return "aarch64_vector_pcs";
+ case CC_AArch64SVEPCS:
+ return "aarch64_sve_pcs";
+ case CC_AMDGPUKernelCall:
+ return "amdgpu_kernel";
+ case CC_IntelOclBicc:
+ return "intel_ocl_bicc";
+ case CC_SpirFunction:
+ return "spir_function";
+ case CC_OpenCLKernel:
+ return "opencl_kernel";
+ case CC_Swift:
+ return "swiftcall";
+ case CC_SwiftAsync:
+ return "swiftasynccall";
+ case CC_PreserveMost:
+ return "preserve_most";
+ case CC_PreserveAll:
+ return "preserve_all";
}
llvm_unreachable("Invalid calling convention.");
@@ -3262,7 +3366,6 @@
FunctionTypeBits.HasExtraBitfields = false;
}
-
// Fill in the trailing argument array.
auto *argSlot = getTrailingObjects<QualType>();
for (unsigned i = 0; i != getNumParams(); ++i) {
@@ -3443,12 +3546,10 @@
// This method is relatively performance sensitive, so as a performance
// shortcut, use one AddInteger call instead of four for the next four
// fields.
- assert(!(unsigned(epi.Variadic) & ~1) &&
- !(unsigned(epi.RefQualifier) & ~3) &&
+ assert(!(unsigned(epi.Variadic) & ~1) && !(unsigned(epi.RefQualifier) & ~3) &&
!(unsigned(epi.ExceptionSpec.Type) & ~15) &&
"Values larger than expected.");
- ID.AddInteger(unsigned(epi.Variadic) +
- (epi.RefQualifier << 1) +
+ ID.AddInteger(unsigned(epi.Variadic) + (epi.RefQualifier << 1) +
(epi.ExceptionSpec.Type << 3));
ID.Add(epi.TypeQuals);
if (epi.ExceptionSpec.Type == EST_Dynamic) {
@@ -3533,9 +3634,7 @@
TypeOfBits.IsUnqual = Kind == TypeOfKind::Unqualified;
}
-bool TypeOfExprType::isSugared() const {
- return !TOExpr->isTypeDependent();
-}
+bool TypeOfExprType::isSugared() const { return !TOExpr->isTypeDependent(); }
QualType TypeOfExprType::desugar() const {
if (isSugared()) {
@@ -3590,7 +3689,7 @@
DependentUnaryTransformType::DependentUnaryTransformType(const ASTContext &C,
QualType BaseType,
UTTKind UKind)
- : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType()) {}
+ : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType()) {}
TagType::TagType(TypeClass TC, const TagDecl *D, QualType can)
: Type(TC, can,
@@ -3607,16 +3706,12 @@
return decl;
}
-TagDecl *TagType::getDecl() const {
- return getInterestingTagDecl(decl);
-}
+TagDecl *TagType::getDecl() const { return getInterestingTagDecl(decl); }
-bool TagType::isBeingDefined() const {
- return getDecl()->isBeingDefined();
-}
+bool TagType::isBeingDefined() const { return getDecl()->isBeingDefined(); }
bool RecordType::hasConstFields() const {
- std::vector<const RecordType*> RecordTypeList;
+ std::vector<const RecordType *> RecordTypeList;
RecordTypeList.push_back(this);
unsigned NextToCheckIndex = 0;
@@ -3664,7 +3759,8 @@
bool AttributedType::isMSTypeSpec() const {
// FIXME: Generate this with TableGen?
switch (getAttrKind()) {
- default: return false;
+ default:
+ return false;
case attr::Ptr32:
case attr::Ptr64:
case attr::SPtr:
@@ -3681,7 +3777,8 @@
bool AttributedType::isCallingConv() const {
// FIXME: Generate this with TableGen.
switch (getAttrKind()) {
- default: return false;
+ default:
+ return false;
case attr::Pcs:
case attr::CDecl:
case attr::FastCall:
@@ -3793,7 +3890,8 @@
}
bool TemplateSpecializationType::anyDependentTemplateArguments(
- const TemplateArgumentListInfo &Args, ArrayRef<TemplateArgument> Converted) {
+ const TemplateArgumentListInfo &Args,
+ ArrayRef<TemplateArgument> Converted) {
return anyDependentTemplateArguments(Args.arguments(), Converted);
}
@@ -3806,7 +3904,7 @@
}
bool TemplateSpecializationType::anyInstantiationDependentTemplateArguments(
- ArrayRef<TemplateArgumentLoc> Args) {
+ ArrayRef<TemplateArgumentLoc> Args) {
for (const TemplateArgumentLoc &ArgLoc : Args) {
if (ArgLoc.getArgument().isInstantiationDependent())
return true;
@@ -3818,9 +3916,8 @@
TemplateName T, ArrayRef<TemplateArgument> Args, QualType Canon,
QualType AliasedType)
: Type(TemplateSpecialization, Canon.isNull() ? QualType(this, 0) : Canon,
- (Canon.isNull()
- ? TypeDependence::DependentInstantiation
- : toSemanticDependence(Canon->getDependence())) |
+ (Canon.isNull() ? TypeDependence::DependentInstantiation
+ : toSemanticDependence(Canon->getDependence())) |
(toTypeDependence(T.getDependence()) &
TypeDependence::UnexpandedPack)),
Template(T) {
@@ -3872,34 +3969,32 @@
getAliasedType().Profile(ID);
}
-void
-TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
- TemplateName T,
- ArrayRef<TemplateArgument> Args,
- const ASTContext &Context) {
+void TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
+ TemplateName T,
+ ArrayRef<TemplateArgument> Args,
+ const ASTContext &Context) {
T.Profile(ID);
for (const TemplateArgument &Arg : Args)
Arg.Profile(ID, Context);
}
-QualType
-QualifierCollector::apply(const ASTContext &Context, QualType QT) const {
+QualType QualifierCollector::apply(const ASTContext &Context,
+ QualType QT) const {
if (!hasNonFastQualifiers())
return QT.withFastQualifiers(getFastQualifiers());
return Context.getQualifiedType(QT, *this);
}
-QualType
-QualifierCollector::apply(const ASTContext &Context, const Type *T) const {
+QualType QualifierCollector::apply(const ASTContext &Context,
+ const Type *T) const {
if (!hasNonFastQualifiers())
return QualType(T, getFastQualifiers());
return Context.getQualifiedType(T, *this);
}
-void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID,
- QualType BaseType,
+void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
ArrayRef<QualType> typeArgs,
ArrayRef<ObjCProtocolDecl *> protocols,
bool isKindOf) {
@@ -3966,9 +4061,7 @@
/// leakage.
template <class Private> class TypePropertyCache {
public:
- static CachedProperties get(QualType T) {
- return get(T.getTypePtr());
- }
+ static CachedProperties get(QualType T) { return get(T.getTypePtr()); }
static CachedProperties get(const Type *T) {
ensure(T);
@@ -3978,7 +4071,8 @@
static void ensure(const Type *T) {
// If the cache is valid, we're okay.
- if (T->TypeBits.isCacheValid()) return;
+ if (T->TypeBits.isCacheValid())
+ return;
// If this type is non-canonical, ask its canonical type for the
// relevant information.
@@ -4014,17 +4108,18 @@
static CachedProperties computeCachedProperties(const Type *T) {
switch (T->getTypeClass()) {
-#define TYPE(Class,Base)
-#define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
+#define TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
#include "clang/AST/TypeNodes.inc"
llvm_unreachable("didn't expect a non-canonical type here");
-#define TYPE(Class,Base)
-#define DEPENDENT_TYPE(Class,Base) case Type::Class:
-#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
+#define TYPE(Class, Base)
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
#include "clang/AST/TypeNodes.inc"
// Treat instantiation-dependent types as external.
- if (!T->isInstantiationDependentType()) T->dump();
+ if (!T->isInstantiationDependentType())
+ T->dump();
assert(T->isInstantiationDependentType());
return CachedProperties(ExternalLinkage, false);
@@ -4050,9 +4145,8 @@
// for linkage purposes (7.1.3)) and the name has linkage; or
// - it is a specialization of a class template (14); or
Linkage L = Tag->getLinkageInternal();
- bool IsLocalOrUnnamed =
- Tag->getDeclContext()->isFunctionOrMethod() ||
- !Tag->hasNameForLinkage();
+ bool IsLocalOrUnnamed = Tag->getDeclContext()->isFunctionOrMethod() ||
+ !Tag->hasNameForLinkage();
return CachedProperties(L, IsLocalOrUnnamed);
}
@@ -4121,14 +4215,14 @@
LinkageInfo LinkageComputer::computeTypeLinkageInfo(const Type *T) {
switch (T->getTypeClass()) {
-#define TYPE(Class,Base)
-#define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
+#define TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
#include "clang/AST/TypeNodes.inc"
llvm_unreachable("didn't expect a non-canonical type here");
-#define TYPE(Class,Base)
-#define DEPENDENT_TYPE(Class,Base) case Type::Class:
-#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
+#define TYPE(Class, Base)
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
#include "clang/AST/TypeNodes.inc"
// Treat instantiation-dependent types as external.
assert(T->isInstantiationDependentType());
@@ -4236,9 +4330,9 @@
QualType type = getCanonicalTypeInternal();
switch (type->getTypeClass()) {
- // We'll only see canonical types here.
-#define NON_CANONICAL_TYPE(Class, Parent) \
- case Type::Class: \
+ // We'll only see canonical types here.
+#define NON_CANONICAL_TYPE(Class, Parent) \
+ case Type::Class: \
llvm_unreachable("non-canonical type");
#define TYPE(Class, Parent)
#include "clang/AST/TypeNodes.inc"
@@ -4267,9 +4361,10 @@
// types unless they're known to be specializations of a class
// template.
case Type::TemplateSpecialization:
- if (TemplateDecl *templateDecl
- = cast<TemplateSpecializationType>(type.getTypePtr())
- ->getTemplateName().getAsTemplateDecl()) {
+ if (TemplateDecl *templateDecl =
+ cast<TemplateSpecializationType>(type.getTypePtr())
+ ->getTemplateName()
+ .getAsTemplateDecl()) {
if (isa<ClassTemplateDecl>(templateDecl))
return false;
}
@@ -4298,22 +4393,19 @@
case BuiltinType::ObjCId:
case BuiltinType::ObjCClass:
case BuiltinType::ObjCSel:
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
- case BuiltinType::Id:
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ case BuiltinType::Id:
#include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
- case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
#include "clang/Basic/OpenCLExtensionTypes.def"
case BuiltinType::OCLSampler:
case BuiltinType::OCLEvent:
case BuiltinType::OCLClkEvent:
case BuiltinType::OCLQueue:
case BuiltinType::OCLReserveID:
-#define SVE_TYPE(Name, Id, SingletonId) \
- case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
- case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
#include "clang/Basic/PPCTypes.def"
#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/RISCVVTypes.def"
@@ -4461,8 +4553,7 @@
}
bool Type::isObjCRetainableType() const {
- return isObjCObjectPointerType() ||
- isBlockPointerType() ||
+ return isObjCObjectPointerType() || isBlockPointerType() ||
isObjCNSObjectType();
}
@@ -4518,7 +4609,8 @@
}
bool Type::hasSizedVLAType() const {
- if (!isVariablyModifiedType()) return false;
+ if (!isVariablyModifiedType())
+ return false;
if (const auto *ptr = getAs<PointerType>())
return ptr->getPointeeType()->hasSizedVLAType();
@@ -4548,8 +4640,7 @@
return DK_objc_weak_lifetime;
}
- if (const auto *RT =
- type->getBaseElementTypeUnsafe()->getAs<RecordType>()) {
+ if (const auto *RT = type->getBaseElementTypeUnsafe()->getAs<RecordType>()) {
const RecordDecl *RD = RT->getDecl();
if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
/// Check if this is a C++ object with a non-trivial destructor.
@@ -4599,9 +4690,9 @@
}
void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
- QualType Deduced, AutoTypeKeyword Keyword,
- bool IsDependent, ConceptDecl *CD,
- ArrayRef<TemplateArgument> Arguments) {
+ QualType Deduced, AutoTypeKeyword Keyword,
+ bool IsDependent, ConceptDecl *CD,
+ ArrayRef<TemplateArgument> Arguments) {
ID.AddPointer(Deduced.getAsOpaquePtr());
ID.AddInteger((unsigned)Keyword);
ID.AddBoolean(IsDependent);
Index: clang/lib/AST/ASTContext.cpp
===================================================================
--- clang/lib/AST/ASTContext.cpp
+++ clang/lib/AST/ASTContext.cpp
@@ -2762,12 +2762,14 @@
}
static bool unionHasUniqueObjectRepresentations(const ASTContext &Context,
- const RecordDecl *RD) {
+ const RecordDecl *RD,
+ bool CheckIfTriviallyCOpyable) {
assert(RD->isUnion() && "Must be union type");
CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl());
for (const auto *Field : RD->fields()) {
- if (!Context.hasUniqueObjectRepresentations(Field->getType()))
+ if (!Context.hasUniqueObjectRepresentations(Field->getType(),
+ CheckIfTriviallyCOpyable))
return false;
CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
if (FieldSize != UnionSize)
@@ -2790,21 +2792,25 @@
static std::optional<int64_t>
structHasUniqueObjectRepresentations(const ASTContext &Context,
- const RecordDecl *RD);
+ const RecordDecl *RD,
+ bool CheckIfTriviallyCopyable);
static std::optional<int64_t>
-getSubobjectSizeInBits(const FieldDecl *Field, const ASTContext &Context) {
+getSubobjectSizeInBits(const FieldDecl *Field, const ASTContext &Context,
+ bool CheckIfTriviallyCopyable) {
if (Field->getType()->isRecordType()) {
const RecordDecl *RD = Field->getType()->getAsRecordDecl();
if (!RD->isUnion())
- return structHasUniqueObjectRepresentations(Context, RD);
+ return structHasUniqueObjectRepresentations(Context, RD,
+ CheckIfTriviallyCopyable);
}
// A _BitInt type may not be unique if it has padding bits
// but if it is a bitfield the padding bits are not used.
bool IsBitIntType = Field->getType()->isBitIntType();
if (!Field->getType()->isReferenceType() && !IsBitIntType &&
- !Context.hasUniqueObjectRepresentations(Field->getType()))
+ !Context.hasUniqueObjectRepresentations(Field->getType(),
+ CheckIfTriviallyCopyable))
return std::nullopt;
int64_t FieldSizeInBits =
@@ -2819,25 +2825,28 @@
return std::nullopt;
}
FieldSizeInBits = BitfieldSize;
- } else if (IsBitIntType &&
- !Context.hasUniqueObjectRepresentations(Field->getType())) {
+ } else if (IsBitIntType && !Context.hasUniqueObjectRepresentations(
+ Field->getType(), CheckIfTriviallyCopyable)) {
return std::nullopt;
}
return FieldSizeInBits;
}
static std::optional<int64_t>
-getSubobjectSizeInBits(const CXXRecordDecl *RD, const ASTContext &Context) {
- return structHasUniqueObjectRepresentations(Context, RD);
+getSubobjectSizeInBits(const CXXRecordDecl *RD, const ASTContext &Context,
+ bool CheckIfTriviallyCopyable) {
+ return structHasUniqueObjectRepresentations(Context, RD,
+ CheckIfTriviallyCopyable);
}
template <typename RangeT>
static std::optional<int64_t> structSubobjectsHaveUniqueObjectRepresentations(
const RangeT &Subobjects, int64_t CurOffsetInBits,
- const ASTContext &Context, const clang::ASTRecordLayout &Layout) {
+ const ASTContext &Context, const clang::ASTRecordLayout &Layout,
+ bool CheckIfTriviallyCopyable) {
for (const auto *Subobject : Subobjects) {
std::optional<int64_t> SizeInBits =
- getSubobjectSizeInBits(Subobject, Context);
+ getSubobjectSizeInBits(Subobject, Context, CheckIfTriviallyCopyable);
if (!SizeInBits)
return std::nullopt;
if (*SizeInBits != 0) {
@@ -2852,7 +2861,8 @@
static std::optional<int64_t>
structHasUniqueObjectRepresentations(const ASTContext &Context,
- const RecordDecl *RD) {
+ const RecordDecl *RD,
+ bool CheckIfTriviallyCopyable) {
assert(!RD->isUnion() && "Must be struct/class type");
const auto &Layout = Context.getASTRecordLayout(RD);
@@ -2873,8 +2883,8 @@
});
std::optional<int64_t> OffsetAfterBases =
- structSubobjectsHaveUniqueObjectRepresentations(Bases, CurOffsetInBits,
- Context, Layout);
+ structSubobjectsHaveUniqueObjectRepresentations(
+ Bases, CurOffsetInBits, Context, Layout, CheckIfTriviallyCopyable);
if (!OffsetAfterBases)
return std::nullopt;
CurOffsetInBits = *OffsetAfterBases;
@@ -2882,7 +2892,8 @@
std::optional<int64_t> OffsetAfterFields =
structSubobjectsHaveUniqueObjectRepresentations(
- RD->fields(), CurOffsetInBits, Context, Layout);
+ RD->fields(), CurOffsetInBits, Context, Layout,
+ CheckIfTriviallyCopyable);
if (!OffsetAfterFields)
return std::nullopt;
CurOffsetInBits = *OffsetAfterFields;
@@ -2890,7 +2901,8 @@
return CurOffsetInBits;
}
-bool ASTContext::hasUniqueObjectRepresentations(QualType Ty) const {
+bool ASTContext::hasUniqueObjectRepresentations(
+ QualType Ty, bool CheckIfTriviallyCopyable) const {
// C++17 [meta.unary.prop]:
// The predicate condition for a template specialization
// has_unique_object_representations<T> shall be
@@ -2912,10 +2924,11 @@
// Arrays are unique only if their element type is unique.
if (Ty->isArrayType())
- return hasUniqueObjectRepresentations(getBaseElementType(Ty));
+ return hasUniqueObjectRepresentations(getBaseElementType(Ty),
+ CheckIfTriviallyCopyable);
// (9.1) - T is trivially copyable...
- if (!Ty.isTriviallyCopyableType(*this))
+ if (CheckIfTriviallyCopyable && !Ty.isTriviallyCopyableType(*this))
return false;
// All integrals and enums are unique.
@@ -2943,10 +2956,11 @@
return false;
if (Record->isUnion())
- return unionHasUniqueObjectRepresentations(*this, Record);
+ return unionHasUniqueObjectRepresentations(*this, Record,
+ CheckIfTriviallyCopyable);
- std::optional<int64_t> StructSize =
- structHasUniqueObjectRepresentations(*this, Record);
+ std::optional<int64_t> StructSize = structHasUniqueObjectRepresentations(
+ *this, Record, CheckIfTriviallyCopyable);
return StructSize && *StructSize == static_cast<int64_t>(getTypeSize(Ty));
}
Index: clang/include/clang/Basic/TokenKinds.def
===================================================================
--- clang/include/clang/Basic/TokenKinds.def
+++ clang/include/clang/Basic/TokenKinds.def
@@ -519,6 +519,7 @@
// Clang-only C++ Type Traits
TYPE_TRAIT_1(__is_trivially_relocatable, IsTriviallyRelocatable, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_equality_comparable, IsTriviallyEqualityComparable, KEYCXX)
TYPE_TRAIT_1(__is_bounded_array, IsBoundedArray, KEYCXX)
TYPE_TRAIT_1(__is_unbounded_array, IsUnboundedArray, KEYCXX)
TYPE_TRAIT_1(__is_nullptr, IsNullPointer, KEYCXX)
Index: clang/include/clang/AST/Type.h
===================================================================
--- clang/include/clang/AST/Type.h
+++ clang/include/clang/AST/Type.h
@@ -899,6 +899,9 @@
/// Return true if this is a trivially relocatable type.
bool isTriviallyRelocatableType(const ASTContext &Context) const;
+ /// Return true if this is a trivially equality comparable type.
+ bool isTriviallyEqualityComparableType(const ASTContext &Context) const;
+
/// Returns true if it is a class and it might be dynamic.
bool mayBeDynamicClass() const;
Index: clang/include/clang/AST/DeclCXX.h
===================================================================
--- clang/include/clang/AST/DeclCXX.h
+++ clang/include/clang/AST/DeclCXX.h
@@ -1446,7 +1446,7 @@
}
/// Notify the class that this destructor is now selected.
- ///
+ ///
/// Important properties of the class depend on destructor properties. Since
/// C++20, it is possible to have multiple destructor declarations in a class
/// out of which one will be selected at the end.
Index: clang/include/clang/AST/ASTContext.h
===================================================================
--- clang/include/clang/AST/ASTContext.h
+++ clang/include/clang/AST/ASTContext.h
@@ -2488,7 +2488,9 @@
/// Return true if the specified type has unique object representations
/// according to (C++17 [meta.unary.prop]p9)
- bool hasUniqueObjectRepresentations(QualType Ty) const;
+ bool
+ hasUniqueObjectRepresentations(QualType Ty,
+ bool CheckIfTriviallyCopyable = true) const;
//===--------------------------------------------------------------------===//
// Type Operators
Index: clang/docs/LanguageExtensions.rst
===================================================================
--- clang/docs/LanguageExtensions.rst
+++ clang/docs/LanguageExtensions.rst
@@ -1507,6 +1507,9 @@
functionally equivalent to copying the underlying bytes and then dropping the
source object on the floor. This is true of trivial types and types which
were made trivially relocatable via the ``clang::trivial_abi`` attribute.
+* ``__is_trivially_equality_comparable`` (Clang): Returns true if comparing two
+ objects of the provided type is known to be equivalent to comparing their
+ value representations.
* ``__is_unbounded_array`` (C++, GNU, Microsoft, Embarcadero)
* ``__is_union`` (C++, GNU, Microsoft, Embarcadero)
* ``__is_unsigned`` (C++, Embarcadero):
@@ -4928,7 +4931,7 @@
`dump`
------
Accepts either a single identifier or an expression. When a single identifier is passed,
-the lookup results for the identifier are printed to `stderr`. When an expression is passed,
+the lookup results for the identifier are printed to `stderr`. When an expression is passed,
the AST for the expression is printed to `stderr`. The expression is an unevaluated operand,
so things like overload resolution and template instantiations are performed,
but the expression has no runtime effects.
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
