Canonicality is a property of qualified types, not unqualified types.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@84891 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/AST/CanonicalType.h b/include/clang/AST/CanonicalType.h
index f22839be5658c3d9b403dc7a6cca7a69ed71e630..8b84bc26799769485891d44130fcf86513c926c0 100644 (file)
--- a/include/clang/AST/CanonicalType.h
+++ b/include/clang/AST/CanonicalType.h
@@ -660,7 +660,7 @@ CanQual<T> CanQual<T>::getFromOpaquePtr(void *Ptr) {
 
 template<typename T>
 CanQual<T> CanQual<T>::CreateUnsafe(QualType Other) {
-  assert((Other.isNull() || Other->isCanonical()) && "Type is not canonical!");
+  assert((Other.isNull() || Other.isCanonical()) && "Type is not canonical!");
   assert((Other.isNull() || isa<T>(Other.getTypePtr())) &&
          "Dynamic type does not meet the static type's requires");
   CanQual<T> Result;

diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index 6b0eb97ca414d69aba77b3e3d8cb0701ed4a26a6..686d86c4bb5eefbbf9fd63b43c171b5fe31b42bf 100644 (file)
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -443,6 +443,8 @@ public:
     return getTypePtr();
   }
 
+  bool isCanonical() const;
+
   /// isNull - Return true if this QualType doesn't point to a type yet.
   bool isNull() const {
     return Value.getPointer().isNull();
@@ -702,7 +704,9 @@ protected:
 public:
   TypeClass getTypeClass() const { return static_cast<TypeClass>(TC); }
 
-  bool isCanonical() const { return CanonicalType.getTypePtr() == this; }
+  bool isCanonicalUnqualified() const {
+    return CanonicalType.getTypePtr() == this;
+  }
 
   /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
   /// object types, function types, and incomplete types.
@@ -2622,6 +2626,13 @@ public:
 
 // Inline function definitions.
 
+inline bool QualType::isCanonical() const {
+  const Type *T = getTypePtr();
+  if (hasQualifiers())
+    return T->isCanonicalUnqualified() && !isa<ArrayType>(T);
+  return T->isCanonicalUnqualified();
+}
+
 inline void QualType::removeConst() {
   removeFastQualifiers(Qualifiers::Const);
 }

diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index 7d9bc0f47255377982c9e61ff10e2f3d84a2724f..292f2ac95d04a966b72ab7cad8f2a9ff583e9b0a 100644 (file)
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -1151,7 +1151,7 @@ QualType ASTContext::getComplexType(QualType T) {
   // If the pointee type isn't canonical, this won't be a canonical type either,
   // so fill in the canonical type field.
   QualType Canonical;
-  if (!T->isCanonical()) {
+  if (!T.isCanonical()) {
     Canonical = getComplexType(getCanonicalType(T));
 
     // Get the new insert position for the node we care about.
@@ -1188,7 +1188,7 @@ QualType ASTContext::getPointerType(QualType T) {
   // If the pointee type isn't canonical, this won't be a canonical type either,
   // so fill in the canonical type field.
   QualType Canonical;
-  if (!T->isCanonical()) {
+  if (!T.isCanonical()) {
     Canonical = getPointerType(getCanonicalType(T));
 
     // Get the new insert position for the node we care about.
@@ -1218,7 +1218,7 @@ QualType ASTContext::getBlockPointerType(QualType T) {
   // If the block pointee type isn't canonical, this won't be a canonical
   // type either so fill in the canonical type field.
   QualType Canonical;
-  if (!T->isCanonical()) {
+  if (!T.isCanonical()) {
     Canonical = getBlockPointerType(getCanonicalType(T));
 
     // Get the new insert position for the node we care about.
@@ -1249,7 +1249,7 @@ QualType ASTContext::getLValueReferenceType(QualType T) {
   // If the referencee type isn't canonical, this won't be a canonical type
   // either, so fill in the canonical type field.
   QualType Canonical;
-  if (!T->isCanonical()) {
+  if (!T.isCanonical()) {
     Canonical = getLValueReferenceType(getCanonicalType(T));
 
     // Get the new insert position for the node we care about.
@@ -1281,7 +1281,7 @@ QualType ASTContext::getRValueReferenceType(QualType T) {
   // If the referencee type isn't canonical, this won't be a canonical type
   // either, so fill in the canonical type field.
   QualType Canonical;
-  if (!T->isCanonical()) {
+  if (!T.isCanonical()) {
     Canonical = getRValueReferenceType(getCanonicalType(T));
 
     // Get the new insert position for the node we care about.
@@ -1313,7 +1313,7 @@ QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) {
   // If the pointee or class type isn't canonical, this won't be a canonical
   // type either, so fill in the canonical type field.
   QualType Canonical;
-  if (!T->isCanonical()) {
+  if (!T.isCanonical()) {
     Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
 
     // Get the new insert position for the node we care about.
@@ -1353,7 +1353,7 @@ QualType ASTContext::getConstantArrayType(QualType EltTy,
   // If the element type isn't canonical, this won't be a canonical type either,
   // so fill in the canonical type field.
   QualType Canonical;
-  if (!EltTy->isCanonical()) {
+  if (!EltTy.isCanonical()) {
     Canonical = getConstantArrayType(getCanonicalType(EltTy), ArySize,
                                      ASM, EltTypeQuals);
     // Get the new insert position for the node we care about.
@@ -1448,7 +1448,7 @@ QualType ASTContext::getIncompleteArrayType(QualType EltTy,
   // either, so fill in the canonical type field.
   QualType Canonical;
 
-  if (!EltTy->isCanonical()) {
+  if (!EltTy.isCanonical()) {
     Canonical = getIncompleteArrayType(getCanonicalType(EltTy),
                                        ASM, EltTypeQuals);
 
@@ -1484,7 +1484,7 @@ QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts) {
   // If the element type isn't canonical, this won't be a canonical type either,
   // so fill in the canonical type field.
   QualType Canonical;
-  if (!vecType->isCanonical()) {
+  if (!vecType.isCanonical()) {
     Canonical = getVectorType(getCanonicalType(vecType), NumElts);
 
     // Get the new insert position for the node we care about.
@@ -1516,7 +1516,7 @@ QualType ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) {
   // If the element type isn't canonical, this won't be a canonical type either,
   // so fill in the canonical type field.
   QualType Canonical;
-  if (!vecType->isCanonical()) {
+  if (!vecType.isCanonical()) {
     Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
 
     // Get the new insert position for the node we care about.
@@ -1580,7 +1580,7 @@ QualType ASTContext::getFunctionNoProtoType(QualType ResultTy, bool NoReturn) {
     return QualType(FT, 0);
 
   QualType Canonical;
-  if (!ResultTy->isCanonical()) {
+  if (!ResultTy.isCanonical()) {
     Canonical = getFunctionNoProtoType(getCanonicalType(ResultTy), NoReturn);
 
     // Get the new insert position for the node we care about.
@@ -1622,11 +1622,11 @@ QualType ASTContext::getFunctionType(QualType ResultTy,const QualType *ArgArray,
     return QualType(FTP, 0);
 
   // Determine whether the type being created is already canonical or not.
-  bool isCanonical = ResultTy->isCanonical();
+  bool isCanonical = ResultTy.isCanonical();
   if (hasExceptionSpec)
     isCanonical = false;
   for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
-    if (!ArgArray[i]->isCanonical())
+    if (!ArgArray[i].isCanonical())
       isCanonical = false;
 
   // If this type isn't canonical, get the canonical version of it.
@@ -1711,7 +1711,7 @@ QualType ASTContext::getTypedefType(TypedefDecl *Decl) {
 QualType
 ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
                                          QualType Replacement) {
-  assert(Replacement->isCanonical()
+  assert(Replacement.isCanonical()
          && "replacement types must always be canonical");
 
   llvm::FoldingSetNodeID ID;
@@ -2499,7 +2499,7 @@ int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) {
 /// routine will assert if passed a built-in type that isn't an integer or enum,
 /// or if it is not canonicalized.
 unsigned ASTContext::getIntegerRank(Type *T) {
-  assert(T->isCanonical() && "T should be canonicalized");
+  assert(T->isCanonicalUnqualified() && "T should be canonicalized");
   if (EnumType* ET = dyn_cast<EnumType>(T))
     T = ET->getDecl()->getIntegerType().getTypePtr();
 
@@ -3628,7 +3628,7 @@ Qualifiers::GC ASTContext::getObjCGCAttrKind(const QualType &Ty) const {
 /// compatible.
 static bool areCompatVectorTypes(const VectorType *LHS,
                                  const VectorType *RHS) {
-  assert(LHS->isCanonical() && RHS->isCanonical());
+  assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified());
   return LHS->getElementType() == RHS->getElementType() &&
          LHS->getNumElements() == RHS->getNumElements();
 }

diff --git a/lib/AST/CXXInheritance.cpp b/lib/AST/CXXInheritance.cpp
index 4a46eab2e60380aade9f4e97b95489d83b7763db..b59b45f6467e32eb6e83ae51bb61519876b7fbbe 100644 (file)
--- a/lib/AST/CXXInheritance.cpp
+++ b/lib/AST/CXXInheritance.cpp
@@ -50,7 +50,7 @@ CXXBasePaths::decl_iterator CXXBasePaths::found_decls_end() {
 /// different base class subobjects of the same type. BaseType must be
 /// an unqualified, canonical class type.
 bool CXXBasePaths::isAmbiguous(QualType BaseType) {
-  assert(BaseType->isCanonical() && "Base type must be the canonical type");
+  assert(BaseType.isCanonical() && "Base type must be the canonical type");
   assert(BaseType.hasQualifiers() == 0 && "Base type must be unqualified");
   std::pair<bool, unsigned>& Subobjects = ClassSubobjects[BaseType];
   return Subobjects.second + (Subobjects.first? 1 : 0) > 1;

diff --git a/lib/AST/DeclTemplate.cpp b/lib/AST/DeclTemplate.cpp
index 7836b3f827ce76f5c9484bbde9b6b2a67d3adb99..9a1c65416f71318839240372d9bafe2c76896bd3 100644 (file)
--- a/lib/AST/DeclTemplate.cpp
+++ b/lib/AST/DeclTemplate.cpp
@@ -299,7 +299,7 @@ void TemplateArgumentListBuilder::Append(const TemplateArgument& Arg) {
   switch (Arg.getKind()) {
     default: break;
     case TemplateArgument::Type:
-      assert(Arg.getAsType()->isCanonical() && "Type must be canonical!");
+      assert(Arg.getAsType().isCanonical() && "Type must be canonical!");
       break;
   }
 

diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
index 0042754f98c0ca65fd64d94b5b2a1941fb102ecb..831b48033a7fceff6b220f91bab4dc11c1b7d45a 100644 (file)
--- a/lib/CodeGen/CGExprScalar.cpp
+++ b/lib/CodeGen/CGExprScalar.cpp
@@ -365,7 +365,7 @@ public:
 /// EmitConversionToBool - Convert the specified expression value to a
 /// boolean (i1) truth value.  This is equivalent to "Val != 0".
 Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
-  assert(SrcType->isCanonical() && "EmitScalarConversion strips typedefs");
+  assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs");
 
   if (SrcType->isRealFloatingType()) {
     // Compare against 0.0 for fp scalars.

diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp
index b981389d1d15b9f75a6e86d704c0730d7b8c46f1..2a44f83598e8ba41ec2e447e7bbbdda4ada7a04e 100644 (file)
--- a/lib/Sema/SemaTemplateDeduction.cpp
+++ b/lib/Sema/SemaTemplateDeduction.cpp
@@ -221,7 +221,7 @@ DeduceTemplateArguments(ASTContext &Context,
                         QualType Arg,
                         Sema::TemplateDeductionInfo &Info,
                         llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
-  assert(Arg->isCanonical() && "Argument type must be canonical");
+  assert(Arg.isCanonical() && "Argument type must be canonical");
 
   // Check whether the template argument is a dependent template-id.
   // FIXME: This is untested code; it can be tested when we implement
@@ -313,7 +313,7 @@ DeduceTemplateArguments(ASTContext &Context,
 /// that corresponds to T. Otherwise, returns T.
 static QualType getUnqualifiedArrayType(ASTContext &Context, QualType T,
                                         Qualifiers &Quals) {
-  assert(T->isCanonical() && "Only operates on canonical types");
+  assert(T.isCanonical() && "Only operates on canonical types");
   if (!isa<ArrayType>(T)) {
     Quals = T.getQualifiers();
     return T.getUnqualifiedType();