diff options
Diffstat (limited to 'clang')
30 files changed, 220 insertions, 167 deletions
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h index 260aca6c893..3cf6788b750 100644 --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -872,9 +872,9 @@ public: /// \brief Determine whether the given types are equivalent after /// cvr-qualifiers have been removed. bool hasSameUnqualifiedType(QualType T1, QualType T2) { - T1 = getCanonicalType(T1); - T2 = getCanonicalType(T2); - return T1.getUnqualifiedType() == T2.getUnqualifiedType(); + CanQualType CT1 = getCanonicalType(T1); + CanQualType CT2 = getCanonicalType(T2); + return CT1.getUnqualifiedType() == CT2.getUnqualifiedType(); } /// \brief Retrieves the "canonical" declaration of diff --git a/clang/include/clang/AST/CanonicalType.h b/clang/include/clang/AST/CanonicalType.h index a53f2f48fd2..9b1187770f6 100644 --- a/clang/include/clang/AST/CanonicalType.h +++ b/clang/include/clang/AST/CanonicalType.h @@ -102,22 +102,22 @@ public: CanProxy<T> operator->() const; /// \brief Retrieve all qualifiers. - Qualifiers getQualifiers() const { return Stored.getQualifiers(); } + Qualifiers getQualifiers() const { return Stored.getLocalQualifiers(); } /// \brief Retrieve the const/volatile/restrict qualifiers. - unsigned getCVRQualifiers() const { return Stored.getCVRQualifiers(); } + unsigned getCVRQualifiers() const { return Stored.getLocalCVRQualifiers(); } /// \brief Determines whether this type has any qualifiers - bool hasQualifiers() const { return Stored.hasQualifiers(); } + bool hasQualifiers() const { return Stored.hasLocalQualifiers(); } bool isConstQualified() const { - return Stored.isConstQualified(); + return Stored.isLocalConstQualified(); } bool isVolatileQualified() const { - return Stored.isVolatileQualified(); + return Stored.isLocalVolatileQualified(); } bool isRestrictQualified() const { - return Stored.isRestrictQualified(); + return Stored.isLocalRestrictQualified(); } /// \brief Retrieve the unqualified form of this type. @@ -638,7 +638,7 @@ struct CanProxyAdaptor<ObjCObjectPointerType> //----------------------------------------------------------------------------// template<typename T> inline CanQual<T> CanQual<T>::getUnqualifiedType() const { - return CanQual<T>::CreateUnsafe(Stored.getUnqualifiedType()); + return CanQual<T>::CreateUnsafe(Stored.getLocalUnqualifiedType()); } template<typename T> diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h index e13792bc3aa..66853b8c9ad 100644 --- a/clang/include/clang/AST/Type.h +++ b/clang/include/clang/AST/Type.h @@ -396,10 +396,6 @@ class QualType { llvm::PointerIntPair<llvm::PointerUnion<const Type*,const ExtQuals*>, Qualifiers::FastWidth> Value; - bool hasExtQuals() const { - return Value.getPointer().is<const ExtQuals*>(); - } - const ExtQuals *getExtQualsUnsafe() const { return Value.getPointer().get<const ExtQuals*>(); } @@ -417,14 +413,14 @@ public: QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {} - unsigned getFastQualifiers() const { return Value.getInt(); } - void setFastQualifiers(unsigned Quals) { Value.setInt(Quals); } + unsigned getLocalFastQualifiers() const { return Value.getInt(); } + void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); } /// Retrieves a pointer to the underlying (unqualified) type. /// This should really return a const Type, but it's not worth /// changing all the users right now. Type *getTypePtr() const { - if (hasNonFastQualifiers()) + if (hasLocalNonFastQualifiers()) return const_cast<Type*>(getExtQualsUnsafe()->getBaseType()); return const_cast<Type*>(getTypePtrUnsafe()); } @@ -452,41 +448,99 @@ public: return Value.getPointer().isNull(); } + /// \brief Determine whether this particular QualType instance has the + /// "const" qualifier set, without looking through typedefs that may have + /// added "const" at a different level. + bool isLocalConstQualified() const { + return (getLocalFastQualifiers() & Qualifiers::Const); + } + + /// \brief Determine whether this type is const-qualified. bool isConstQualified() const { - return (getFastQualifiers() & Qualifiers::Const); + // FIXME: Look through sugar types. + return isLocalConstQualified(); + } + + /// \brief Determine whether this particular QualType instance has the + /// "restrict" qualifier set, without looking through typedefs that may have + /// added "restrict" at a different level. + bool isLocalRestrictQualified() const { + return (getLocalFastQualifiers() & Qualifiers::Restrict); } + + /// \brief Determine whether this type is restrict-qualified. bool isRestrictQualified() const { - return (getFastQualifiers() & Qualifiers::Restrict); + // FIXME: Look through sugar types. + return isLocalRestrictQualified(); + } + + /// \brief Determine whether this particular QualType instance has the + /// "volatile" qualifier set, without looking through typedefs that may have + /// added "volatile" at a different level. + bool isLocalVolatileQualified() const { + return (hasLocalNonFastQualifiers() && getExtQualsUnsafe()->hasVolatile()); } + + /// \brief Determine whether this type is volatile-qualified. bool isVolatileQualified() const { - return (hasNonFastQualifiers() && getExtQualsUnsafe()->hasVolatile()); + // FIXME: Look through sugar types. + return isLocalVolatileQualified(); + } + + /// \brief Determine whether this particular QualType instance has any + /// qualifiers, without looking through any typedefs that might add + /// qualifiers at a different level. + bool hasLocalQualifiers() const { + return getLocalFastQualifiers() || hasLocalNonFastQualifiers(); } - // Determines whether this type has any direct qualifiers. + /// \brief Determine whether this type has any qualifiers. bool hasQualifiers() const { - return getFastQualifiers() || hasNonFastQualifiers(); + // FIXME: Look for qualifiers at any level. + return hasLocalQualifiers(); } - - bool hasNonFastQualifiers() const { - return hasExtQuals(); + + /// \brief Determine whether this particular QualType instance has any + /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType + /// instance. + bool hasLocalNonFastQualifiers() const { + return Value.getPointer().is<const ExtQuals*>(); } - // Retrieves the set of qualifiers belonging to this type. - Qualifiers getQualifiers() const { + /// \brief Retrieve the set of qualifiers local to this particular QualType + /// instance, not including any qualifiers acquired through typedefs or + /// other sugar. + Qualifiers getLocalQualifiers() const { Qualifiers Quals; - if (hasNonFastQualifiers()) + if (hasLocalNonFastQualifiers()) Quals = getExtQualsUnsafe()->getQualifiers(); - Quals.addFastQualifiers(getFastQualifiers()); + Quals.addFastQualifiers(getLocalFastQualifiers()); return Quals; } - // Retrieves the CVR qualifiers of this type. - unsigned getCVRQualifiers() const { - unsigned CVR = getFastQualifiers(); - if (isVolatileQualified()) CVR |= Qualifiers::Volatile; + /// \brief Retrieve the set of qualifiers applied to this type. + Qualifiers getQualifiers() const { + // FIXME: Collect qualifiers from all levels. + return getLocalQualifiers(); + } + + /// \brief Retrieve the set of CVR (const-volatile-restrict) qualifiers + /// local to this particular QualType instance, not including any qualifiers + /// acquired through typedefs or other sugar. + unsigned getLocalCVRQualifiers() const { + unsigned CVR = getLocalFastQualifiers(); + if (isLocalVolatileQualified()) + CVR |= Qualifiers::Volatile; return CVR; } + /// \brief Retrieve the set of CVR (const-volatile-restrict) qualifiers + /// applied to this type. + unsigned getCVRQualifiers() const { + // FIXME: Collect qualifiers from all levels. + return getLocalCVRQualifiers(); + } + bool isConstant(ASTContext& Ctx) const { return QualType::isConstant(*this, Ctx); } @@ -508,6 +562,9 @@ public: Value.setInt(Value.getInt() | TQs); } + // FIXME: The remove* functions are semantically broken, because they might + // not remove a qualifier stored on a typedef. Most of the with* functions + // have the same problem. void removeConst(); void removeVolatile(); void removeRestrict(); @@ -540,8 +597,18 @@ public: return T; } - QualType getUnqualifiedType() const { return QualType(getTypePtr(), 0); } + /// \brief Return this type with all of the instance-specific qualifiers + /// removed, but without removing any qualifiers that may have been applied + /// through typedefs. + QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); } + /// \brief Return the unqualified form of the given type, which might be + /// desugared to eliminate qualifiers introduced via typedefs. + QualType getUnqualifiedType() const { + // FIXME: We may have to desugar the type to remove qualifiers. + return getLocalUnqualifiedType(); + } + bool isMoreQualifiedThan(QualType Other) const; bool isAtLeastAsQualifiedAs(QualType Other) const; QualType getNonReferenceType() const; @@ -2529,8 +2596,8 @@ public: /// Collect any qualifiers on the given type and return an /// unqualified type. const Type *strip(QualType QT) { - addFastQualifiers(QT.getFastQualifiers()); - if (QT.hasNonFastQualifiers()) { + addFastQualifiers(QT.getLocalFastQualifiers()); + if (QT.hasLocalNonFastQualifiers()) { const ExtQuals *EQ = QT.getExtQualsUnsafe(); Context = &EQ->getContext(); addQualifiers(EQ->getQualifiers()); @@ -2552,13 +2619,13 @@ public: inline bool QualType::isCanonical() const { const Type *T = getTypePtr(); - if (hasQualifiers()) + if (hasLocalQualifiers()) return T->isCanonicalUnqualified() && !isa<ArrayType>(T); return T->isCanonicalUnqualified(); } inline bool QualType::isCanonicalAsParam() const { - if (hasQualifiers()) return false; + if (hasLocalQualifiers()) return false; const Type *T = getTypePtr(); return T->isCanonicalUnqualified() && !isa<FunctionType>(T) && !isa<ArrayType>(T); @@ -2598,14 +2665,14 @@ inline void QualType::removeCVRQualifiers(unsigned Mask) { /// getAddressSpace - Return the address space of this type. inline unsigned QualType::getAddressSpace() const { - if (hasNonFastQualifiers()) { + if (hasLocalNonFastQualifiers()) { const ExtQuals *EQ = getExtQualsUnsafe(); if (EQ->hasAddressSpace()) return EQ->getAddressSpace(); } QualType CT = getTypePtr()->getCanonicalTypeInternal(); - if (CT.hasNonFastQualifiers()) { + if (CT.hasLocalNonFastQualifiers()) { const ExtQuals *EQ = CT.getExtQualsUnsafe(); if (EQ->hasAddressSpace()) return EQ->getAddressSpace(); @@ -2620,14 +2687,14 @@ inline unsigned QualType::getAddressSpace() const { /// getObjCGCAttr - Return the gc attribute of this type. inline Qualifiers::GC QualType::getObjCGCAttr() const { - if (hasNonFastQualifiers()) { + if (hasLocalNonFastQualifiers()) { const ExtQuals *EQ = getExtQualsUnsafe(); if (EQ->hasObjCGCAttr()) return EQ->getObjCGCAttr(); } QualType CT = getTypePtr()->getCanonicalTypeInternal(); - if (CT.hasNonFastQualifiers()) { + if (CT.hasLocalNonFastQualifiers()) { const ExtQuals *EQ = CT.getExtQualsUnsafe(); if (EQ->hasObjCGCAttr()) return EQ->getObjCGCAttr(); @@ -2705,28 +2772,26 @@ inline const ObjCInterfaceType *Type::getAsPointerToObjCInterfaceType() const { return 0; } -// NOTE: All of these methods use "getUnqualifiedType" to strip off address -// space qualifiers if present. inline bool Type::isFunctionType() const { - return isa<FunctionType>(CanonicalType.getUnqualifiedType()); + return isa<FunctionType>(CanonicalType); } inline bool Type::isPointerType() const { - return isa<PointerType>(CanonicalType.getUnqualifiedType()); + return isa<PointerType>(CanonicalType); } inline bool Type::isAnyPointerType() const { return isPointerType() || isObjCObjectPointerType(); } inline bool Type::isBlockPointerType() const { - return isa<BlockPointerType>(CanonicalType.getUnqualifiedType()); + return isa<BlockPointerType>(CanonicalType); } inline bool Type::isReferenceType() const { - return isa<ReferenceType>(CanonicalType.getUnqualifiedType()); + return isa<ReferenceType>(CanonicalType); } inline bool Type::isLValueReferenceType() const { - return isa<LValueReferenceType>(CanonicalType.getUnqualifiedType()); + return isa<LValueReferenceType>(CanonicalType); } inline bool Type::isRValueReferenceType() const { - return isa<RValueReferenceType>(CanonicalType.getUnqualifiedType()); + return isa<RValueReferenceType>(CanonicalType); } inline bool Type::isFunctionPointerType() const { if (const PointerType* T = getAs<PointerType>()) @@ -2735,7 +2800,7 @@ inline bool Type::isFunctionPointerType() const { return false; } inline bool Type::isMemberPointerType() const { - return isa<MemberPointerType>(CanonicalType.getUnqualifiedType()); + return isa<MemberPointerType>(CanonicalType); } inline bool Type::isMemberFunctionPointerType() const { if (const MemberPointerType* T = getAs<MemberPointerType>()) @@ -2744,37 +2809,37 @@ inline bool Type::isMemberFunctionPointerType() const { return false; } inline bool Type::isArrayType() const { - return isa<ArrayType>(CanonicalType.getUnqualifiedType()); + return isa<ArrayType>(CanonicalType); } inline bool Type::isConstantArrayType() const { - return isa<ConstantArrayType>(CanonicalType.getUnqualifiedType()); + return isa<ConstantArrayType>(CanonicalType); } inline bool Type::isIncompleteArrayType() const { - return isa<IncompleteArrayType>(CanonicalType.getUnqualifiedType()); + return isa<IncompleteArrayType>(CanonicalType); } inline bool Type::isVariableArrayType() const { - return isa<VariableArrayType>(CanonicalType.getUnqualifiedType()); + return isa<VariableArrayType>(CanonicalType); } inline bool Type::isDependentSizedArrayType() const { - return isa<DependentSizedArrayType>(CanonicalType.getUnqualifiedType()); + return isa<DependentSizedArrayType>(CanonicalType); } inline bool Type::isRecordType() const { - return isa<RecordType>(CanonicalType.getUnqualifiedType()); + return isa<RecordType>(CanonicalType); } inline bool Type::isAnyComplexType() const { - return isa<ComplexType>(CanonicalType.getUnqualifiedType()); + return isa<ComplexType>(CanonicalType); } inline bool Type::isVectorType() const { - return isa<VectorType>(CanonicalType.getUnqualifiedType()); + return isa<VectorType>(CanonicalType); } inline bool Type::isExtVectorType() const { - return isa<ExtVectorType>(CanonicalType.getUnqualifiedType()); + return isa<ExtVectorType>(CanonicalType); } inline bool Type::isObjCObjectPointerType() const { - return isa<ObjCObjectPointerType>(CanonicalType.getUnqualifiedType()); + return isa<ObjCObjectPointerType>(CanonicalType); } inline bool Type::isObjCInterfaceType() const { - return isa<ObjCInterfaceType>(CanonicalType.getUnqualifiedType()); + return isa<ObjCInterfaceType>(CanonicalType); } inline bool Type::isObjCQualifiedIdType() const { if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) @@ -2800,7 +2865,7 @@ inline bool Type::isObjCBuiltinType() const { return isObjCIdType() || isObjCClassType(); } inline bool Type::isTemplateTypeParmType() const { - return isa<TemplateTypeParmType>(CanonicalType.getUnqualifiedType()); + return isa<TemplateTypeParmType>(CanonicalType); } inline bool Type::isSpecificBuiltinType(unsigned K) const { diff --git a/clang/include/clang/AST/TypeLoc.h b/clang/include/clang/AST/TypeLoc.h index a06b9b82d0d..8ac8c22a8ee 100644 --- a/clang/include/clang/AST/TypeLoc.h +++ b/clang/include/clang/AST/TypeLoc.h @@ -58,7 +58,7 @@ public: : Ty(ty), Data(opaqueData) { } TypeLocClass getTypeLocClass() const { - if (getType().hasQualifiers()) return Qualified; + if (getType().hasLocalQualifiers()) return Qualified; return (TypeLocClass) getType()->getTypeClass(); } @@ -155,7 +155,7 @@ public: } static bool classof(const TypeLoc *TL) { - return !TL->getType().hasQualifiers(); + return !TL->getType().hasLocalQualifiers(); } static bool classof(const UnqualTypeLoc *TL) { return true; } }; @@ -200,7 +200,7 @@ public: } static bool classof(const TypeLoc *TL) { - return TL->getType().hasQualifiers(); + return TL->getType().hasLocalQualifiers(); } static bool classof(const QualifiedTypeLoc *TL) { return true; } }; diff --git a/clang/include/clang/Frontend/PCHWriter.h b/clang/include/clang/Frontend/PCHWriter.h index 22427eb6710..b520f4be1d3 100644 --- a/clang/include/clang/Frontend/PCHWriter.h +++ b/clang/include/clang/Frontend/PCHWriter.h @@ -52,7 +52,8 @@ struct UnsafeQualTypeDenseMapInfo { return QualType::getFromOpaquePtr((void*) 2); } static inline unsigned getHashValue(QualType T) { - assert(!T.getFastQualifiers() && "hash invalid for types with fast quals"); + assert(!T.getLocalFastQualifiers() && + "hash invalid for types with fast quals"); uintptr_t v = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr()); return (unsigned(v) >> 4) ^ (unsigned(v) >> 9); } diff --git a/clang/include/clang/Frontend/TypeXML.def b/clang/include/clang/Frontend/TypeXML.def index 6aca15a7542..35f5debe5cf 100644 --- a/clang/include/clang/Frontend/TypeXML.def +++ b/clang/include/clang/Frontend/TypeXML.def @@ -65,9 +65,9 @@ NODE_XML(QualType, "CvQualifiedType") ID_ATTRIBUTE_XML TYPE_ATTRIBUTE_XML(getTypePtr()) // the qualified type, e.g. for 'T* const' it's 'T*' - ATTRIBUTE_OPT_XML(isConstQualified(), "const") // boolean - ATTRIBUTE_OPT_XML(isVolatileQualified(), "volatile") // boolean - ATTRIBUTE_OPT_XML(isRestrictQualified(), "restrict") // boolean + ATTRIBUTE_OPT_XML(isLocalConstQualified(), "const") // boolean + ATTRIBUTE_OPT_XML(isLocalVolatileQualified(), "volatile") // boolean + ATTRIBUTE_OPT_XML(isLocalRestrictQualified(), "restrict") // boolean ATTRIBUTE_OPT_XML(getObjCGCAttr(), "objc_gc") // Qualifiers::GC ATTRIBUTE_OPT_XML(getAddressSpace(), "address_space") // unsigned END_NODE_XML diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index 9850ad6f53a..1b3e09291dd 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -1186,7 +1186,7 @@ QualType ASTContext::getNoReturnType(QualType T) { } } - return getQualifiedType(ResultType, T.getQualifiers()); + return getQualifiedType(ResultType, T.getLocalQualifiers()); } /// getComplexType - Return the uniqued reference to the type for a complex @@ -2435,7 +2435,7 @@ ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) { const ArrayType *ASTContext::getAsArrayType(QualType T) { // Handle the non-qualified case efficiently. - if (!T.hasQualifiers()) { + if (!T.hasLocalQualifiers()) { // Handle the common positive case fast. if (const ArrayType *AT = dyn_cast<ArrayType>(T)) return AT; @@ -4204,8 +4204,8 @@ QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) { return LHS; // If the qualifiers are different, the types aren't compatible... mostly. - Qualifiers LQuals = LHSCan.getQualifiers(); - Qualifiers RQuals = RHSCan.getQualifiers(); + Qualifiers LQuals = LHSCan.getLocalQualifiers(); + Qualifiers RQuals = RHSCan.getLocalQualifiers(); if (LQuals != RQuals) { // If any of these qualifiers are different, we have a type // mismatch. diff --git a/clang/lib/AST/CXXInheritance.cpp b/clang/lib/AST/CXXInheritance.cpp index d4f6e871731..023bca43633 100644 --- a/clang/lib/AST/CXXInheritance.cpp +++ b/clang/lib/AST/CXXInheritance.cpp @@ -99,8 +99,8 @@ bool CXXRecordDecl::lookupInBases(BaseMatchesCallback *BaseMatches, for (base_class_const_iterator BaseSpec = bases_begin(), BaseSpecEnd = bases_end(); BaseSpec != BaseSpecEnd; ++BaseSpec) { // Find the record of the base class subobjects for this type. - QualType BaseType = Context.getCanonicalType(BaseSpec->getType()); - BaseType = BaseType.getUnqualifiedType(); + QualType BaseType = Context.getCanonicalType(BaseSpec->getType()) + .getUnqualifiedType(); // C++ [temp.dep]p3: // In the definition of a class template or a member of a class template, diff --git a/clang/lib/AST/DeclCXX.cpp b/clang/lib/AST/DeclCXX.cpp index 9867e5a8809..bfa338b3659 100644 --- a/clang/lib/AST/DeclCXX.cpp +++ b/clang/lib/AST/DeclCXX.cpp @@ -211,7 +211,7 @@ bool CXXRecordDecl::hasConstCopyAssignment(ASTContext &Context, if (!ArgType.isConstQualified()) AcceptsConst = false; } - if (Context.getCanonicalType(ArgType).getUnqualifiedType() != ClassType) + if (!Context.hasSameUnqualifiedType(ArgType, ClassType)) continue; MD = Method; // We have a single argument of type cv X or cv X&, i.e. we've found the @@ -276,7 +276,7 @@ void CXXRecordDecl::addedAssignmentOperator(ASTContext &Context, QualType ClassType = Context.getCanonicalType(Context.getTypeDeclType( const_cast<CXXRecordDecl*>(this))); - if (ClassType != Context.getCanonicalType(ArgType)) + if (!Context.hasSameUnqualifiedType(ClassType, ArgType)) return; // This is a copy assignment operator. diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp index 234d38a59ff..a4823337828 100644 --- a/clang/lib/AST/TypePrinter.cpp +++ b/clang/lib/AST/TypePrinter.cpp @@ -63,7 +63,7 @@ void TypePrinter::Print(QualType T, std::string &S) { return; // Print qualifiers as appropriate. - Qualifiers Quals = T.getQualifiers(); + Qualifiers Quals = T.getLocalQualifiers(); if (!Quals.empty()) { std::string TQS; Quals.getAsStringInternal(TQS, Policy); @@ -550,7 +550,8 @@ void TypePrinter::PrintObjCObjectPointer(const ObjCObjectPointerType *T, ObjCQIString += '>'; } - T->getPointeeType().getQualifiers().getAsStringInternal(ObjCQIString, Policy); + T->getPointeeType().getLocalQualifiers().getAsStringInternal(ObjCQIString, + Policy); if (!T->isObjCIdType() && !T->isObjCQualifiedIdType()) ObjCQIString += " *"; // Don't forget the implicit pointer. diff --git a/clang/lib/Analysis/CFRefCount.cpp b/clang/lib/Analysis/CFRefCount.cpp index a0846b1abf5..55e5f174cb9 100644 --- a/clang/lib/Analysis/CFRefCount.cpp +++ b/clang/lib/Analysis/CFRefCount.cpp @@ -1537,7 +1537,7 @@ RetainSummaryManager::getCommonMethodSummary(const ObjCMethodDecl* MD, E = MD->param_end(); I != E; ++I, ++i) if (ParmVarDecl *PD = *I) { QualType Ty = Ctx.getCanonicalType(PD->getType()); - if (Ty.getUnqualifiedType() == Ctx.VoidPtrTy) + if (Ty.getLocalUnqualifiedType() == Ctx.VoidPtrTy) ScratchArgs = AF.Add(ScratchArgs, i, StopTracking); } } diff --git a/clang/lib/Analysis/SValuator.cpp b/clang/lib/Analysis/SValuator.cpp index 573cac315b3..ac727b0ac69 100644 --- a/clang/lib/Analysis/SValuator.cpp +++ b/clang/lib/Analysis/SValuator.cpp @@ -62,8 +62,7 @@ SValuator::CastResult SValuator::EvalCast(SVal val, const GRState *state, ASTContext &C = ValMgr.getContext(); // For const casts, just propagate the value. - if (C.getCanonicalType(castTy).getUnqualifiedType() == - C.getCanonicalType(originalTy).getUnqualifiedType()) + if (C.hasSameUnqualifiedType(castTy, originalTy)) return CastResult(state, val); // Check for casts from pointers to integers. diff --git a/clang/lib/Analysis/Store.cpp b/clang/lib/Analysis/Store.cpp index afe2b4e7bd6..2fd72ac0a14 100644 --- a/clang/lib/Analysis/Store.cpp +++ b/clang/lib/Analysis/Store.cpp @@ -64,7 +64,7 @@ const MemRegion *StoreManager::CastRegion(const MemRegion *R, QualType CastToTy) QualType CanonPointeeTy = Ctx.getCanonicalType(PointeeTy); // Handle casts to void*. We just pass the region through. - if (CanonPointeeTy.getUnqualifiedType() == Ctx.VoidTy) + if (CanonPointeeTy.getLocalUnqualifiedType() == Ctx.VoidTy) return R; // Handle casts from compatible types. @@ -199,9 +199,7 @@ SVal StoreManager::CastRetrievedVal(SVal V, const TypedRegion *R, if (castTy.isNull()) return V; - assert(Ctx.getCanonicalType(castTy).getUnqualifiedType() == - Ctx.getCanonicalType(R->getValueType(Ctx)).getUnqualifiedType()); - + assert(Ctx.hasSameUnqualifiedType(castTy, R->getValueType(Ctx))); return V; } diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp index 41ffddd23aa..05516672108 100644 --- a/clang/lib/CodeGen/CGDebugInfo.cpp +++ b/clang/lib/CodeGen/CGDebugInfo.cpp @@ -851,7 +851,7 @@ llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIType CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DICompileUnit Unit) { // Handle qualifiers, which recursively handles what they refer to. - if (Ty.hasQualifiers()) + if (Ty.hasLocalQualifiers()) return CreateQualifiedType(Ty, Unit); // Work out details of type. diff --git a/clang/lib/CodeGen/Mangle.cpp b/clang/lib/CodeGen/Mangle.cpp index 91e89fb711a..0a7124de362 100644 --- a/clang/lib/CodeGen/Mangle.cpp +++ b/clang/lib/CodeGen/Mangle.cpp @@ -744,15 +744,15 @@ void CXXNameMangler::mangleType(QualType T) { // Only operate on the canonical type! T = Context.getASTContext().getCanonicalType(T); - bool IsSubstitutable = T.hasQualifiers() || !isa<BuiltinType>(T); + bool IsSubstitutable = T.hasLocalQualifiers() || !isa<BuiltinType>(T); if (IsSubstitutable && mangleSubstitution(T)) return; - if (Qualifiers Quals = T.getQualifiers()) { + if (Qualifiers Quals = T.getLocalQualifiers()) { mangleQualifiers(Quals); // Recurse: even if the qualified type isn't yet substitutable, // the unqualified type might be. - mangleType(T.getUnqualifiedType()); + mangleType(T.getLocalUnqualifiedType()); } else { switch (T->getTypeClass()) { #define ABSTRACT_TYPE(CLASS, PARENT) diff --git a/clang/lib/Frontend/DocumentXML.cpp b/clang/lib/Frontend/DocumentXML.cpp index d92d4cb7b8d..0263c30bfd5 100644 --- a/clang/lib/Frontend/DocumentXML.cpp +++ b/clang/lib/Frontend/DocumentXML.cpp @@ -135,7 +135,7 @@ void DocumentXML::finalize() { for (XML::IdMap<QualType>::iterator i = Types.begin(), e = Types.end(); i != e; ++i) { - if (i->first.hasQualifiers()) { + if (i->first.hasLocalQualifiers()) { writeTypeToXML(i->first); addAttribute("id", getPrefixedId(i->second, ID_NORMAL)); toParent(); @@ -205,7 +205,7 @@ void DocumentXML::addTypeRecursively(const QualType& pType) { addTypeRecursively(pType.getTypePtr()); // beautifier: a non-qualified type shall be transparent - if (!pType.hasQualifiers()) + if (!pType.hasLocalQualifiers()) { Types[pType] = BasicTypes[pType.getTypePtr()]; } diff --git a/clang/lib/Frontend/PCHWriter.cpp b/clang/lib/Frontend/PCHWriter.cpp index 2dcb8b0ceec..8a45ebce1b9 100644 --- a/clang/lib/Frontend/PCHWriter.cpp +++ b/clang/lib/Frontend/PCHWriter.cpp @@ -1248,9 +1248,9 @@ void PCHWriter::WriteType(QualType T) { // Emit the type's representation. PCHTypeWriter W(*this, Record); - if (T.hasNonFastQualifiers()) { - Qualifiers Qs = T.getQualifiers(); - AddTypeRef(T.getUnqualifiedType(), Record); + if (T.hasLocalNonFastQualifiers()) { + Qualifiers Qs = T.getLocalQualifiers(); + AddTypeRef(T.getLocalUnqualifiedType(), Record); Record.push_back(Qs.getAsOpaqueValue()); W.Code = pch::TYPE_EXT_QUAL; } else { @@ -2154,10 +2154,10 @@ void PCHWriter::AddTypeRef(QualType T, RecordData &Record) { return; } - unsigned FastQuals = T.getFastQualifiers(); + unsigned FastQuals = T.getLocalFastQualifiers(); T.removeFastQualifiers(); - if (T.hasNonFastQualifiers()) { + if (T.hasLocalNonFastQualifiers()) { pch::TypeID &ID = TypeIDs[T]; if (ID == 0) { // We haven't seen these qualifiers applied to this type before. @@ -2172,7 +2172,7 @@ void PCHWriter::AddTypeRef(QualType T, RecordData &Record) { return; } - assert(!T.hasQualifiers()); + assert(!T.hasLocalQualifiers()); if (const BuiltinType *BT = dyn_cast<BuiltinType>(T.getTypePtr())) { pch::TypeID ID = 0; diff --git a/clang/lib/Sema/SemaCXXCast.cpp b/clang/lib/Sema/SemaCXXCast.cpp index 3d68e6a1093..e5ad338502d 100644 --- a/clang/lib/Sema/SemaCXXCast.cpp +++ b/clang/lib/Sema/SemaCXXCast.cpp @@ -737,10 +737,8 @@ TryStaticMemberPointerUpcast(Sema &Self, QualType SrcType, QualType DestType, } // T == T, modulo cv - if (Self.Context.getCanonicalType( - SrcMemPtr->getPointeeType().getUnqualifiedType()) != - Self.Context.getCanonicalType(DestMemPtr->getPointeeType(). - getUnqualifiedType())) + if (!Self.Context.hasSameUnqualifiedType(SrcMemPtr->getPointeeType(), + DestMemPtr->getPointeeType())) return TC_NotApplicable; // B base of D diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 38b6ebeefab..92f1ba5d6ad 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -628,8 +628,7 @@ Action::OwningExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) { return ExprError(); } - if (Context.getCanonicalType(FAType).getUnqualifiedType() != - Context.getCanonicalType(SAType).getUnqualifiedType()) { + if (!Context.hasSameUnqualifiedType(FAType, SAType)) { Diag(TheCall->getLocStart(), diag::err_shufflevector_incompatible_vector) << SourceRange(TheCall->getArg(0)->getLocStart(), TheCall->getArg(1)->getLocEnd()); diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index c6bbb9a438f..502a0f1ab2c 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -1698,9 +1698,8 @@ static bool isNearlyMatchingFunction(ASTContext &Context, QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType(); QualType DefParamTy = Definition->getParamDecl(Idx)->getType(); - DeclParamTy = Context.getCanonicalType(DeclParamTy.getNonReferenceType()); - DefParamTy = Context.getCanonicalType(DefParamTy.getNonReferenceType()); - if (DeclParamTy.getUnqualifiedType() != DefParamTy.getUnqualifiedType()) + if (!Context.hasSameUnqualifiedType(DeclParamTy.getNonReferenceType(), + DefParamTy.getNonReferenceType())) return false; } diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index b0e18d865cf..56381e76f87 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -587,7 +587,7 @@ bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases, for (unsigned idx = 0; idx < NumBases; ++idx) { QualType NewBaseType = Context.getCanonicalType(Bases[idx]->getType()); - NewBaseType = NewBaseType.getUnqualifiedType(); + NewBaseType = NewBaseType.getLocalUnqualifiedType(); if (KnownBaseTypes[NewBaseType]) { // C++ [class.mi]p3: @@ -1140,8 +1140,7 @@ Sema::BuildBaseInitializer(QualType BaseType, Expr **Args, const CXXBaseSpecifier *DirectBaseSpec = 0; for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(); Base != ClassDecl->bases_end(); ++Base) { - if (Context.getCanonicalType(BaseType).getUnqualifiedType() == - Context.getCanonicalType(Base->getType()).getUnqualifiedType()) { + if (Context.hasSameUnqualifiedType(BaseType, Base->getType())) { // We found a direct base of this type. That's what we're // initializing. DirectBaseSpec = &*Base; @@ -3649,8 +3648,8 @@ Sema::CompareReferenceRelationship(SourceLocation Loc, QualType T1 = Context.getCanonicalType(OrigT1); QualType T2 = Context.getCanonicalType(OrigT2); - QualType UnqualT1 = T1.getUnqualifiedType(); - QualType UnqualT2 = T2.getUnqualifiedType(); + QualType UnqualT1 = T1.getLocalUnqualifiedType(); + QualType UnqualT2 = T2.getLocalUnqualifiedType(); // C++ [dcl.init.ref]p4: // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is @@ -4756,7 +4755,7 @@ bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New, QualType COldTy = Context.getCanonicalType(OldTy); if (CNewTy == COldTy && - CNewTy.getCVRQualifiers() == COldTy.getCVRQualifiers()) + CNewTy.getLocalCVRQualifiers() == COldTy.getLocalCVRQualifiers()) return false; // Check if the return types are covariant @@ -4785,7 +4784,7 @@ bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New, return true; } - if (NewClassTy.getUnqualifiedType() != OldClassTy.getUnqualifiedType()) { + if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) { // Check if the new class derives from the old class. if (!IsDerivedFrom(NewClassTy, OldClassTy)) { Diag(New->getLocation(), @@ -4807,7 +4806,7 @@ bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New, } // The qualifiers of the return types must be the same. - if (CNewTy.getCVRQualifiers() != COldTy.getCVRQualifiers()) { + if (CNewTy.getLocalCVRQualifiers() != COldTy.getLocalCVRQualifiers()) { Diag(New->getLocation(), diag::err_covariant_return_type_different_qualifications) << New->getDeclName() << NewTy << OldTy; diff --git a/clang/lib/Sema/SemaExceptionSpec.cpp b/clang/lib/Sema/SemaExceptionSpec.cpp index bdd00b84049..25af0528d8b 100644 --- a/clang/lib/Sema/SemaExceptionSpec.cpp +++ b/clang/lib/Sema/SemaExceptionSpec.cpp @@ -183,7 +183,7 @@ bool Sema::CheckExceptionSpecSubset( SubIsPointer = true; } bool SubIsClass = CanonicalSubT->isRecordType(); - CanonicalSubT = CanonicalSubT.getUnqualifiedType(); + CanonicalSubT = CanonicalSubT.getLocalUnqualifiedType(); CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, /*DetectVirtual=*/false); @@ -205,7 +205,7 @@ bool Sema::CheckExceptionSpecSubset( continue; } } - CanonicalSuperT = CanonicalSuperT.getUnqualifiedType(); + CanonicalSuperT = CanonicalSuperT.getLocalUnqualifiedType(); // If the types are the same, move on to the next type in the subset. if (CanonicalSubT == CanonicalSuperT) { Contained = true; diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index 0d4ce609136..b089ffe92f3 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -3070,8 +3070,7 @@ Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg initlist, static CastExpr::CastKind getScalarCastKind(ASTContext &Context, QualType SrcTy, QualType DestTy) { - if (Context.getCanonicalType(SrcTy).getUnqualifiedType() == - Context.getCanonicalType(DestTy).getUnqualifiedType()) + if (Context.hasSameUnqualifiedType(SrcTy, DestTy)) return CastExpr::CK_NoOp; if (SrcTy->hasPointerRepresentation()) { @@ -3122,8 +3121,7 @@ bool Sema::CheckCastTypes(SourceRange TyR, QualType castType, Expr *&castExpr, } if (!castType->isScalarType() && !castType->isVectorType()) { - if (Context.getCanonicalType(castType).getUnqualifiedType() == - Context.getCanonicalType(castExpr->getType().getUnqualifiedType()) && + if (Context.hasSameUnqualifiedType(castType, castExpr->getType()) && (castType->isStructureType() || castType->isUnionType())) { // GCC struct/union extension: allow cast to self. // FIXME: Check that the cast destination type is complete. @@ -3139,8 +3137,8 @@ bool Sema::CheckCastTypes(SourceRange TyR, QualType castType, Expr *&castExpr, RecordDecl::field_iterator Field, FieldEnd; for (Field = RD->field_begin(), FieldEnd = RD->field_end(); Field != FieldEnd; ++Field) { - if (Context.getCanonicalType(Field->getType()).getUnqualifiedType() == - Context.getCanonicalType(castExpr->getType()).getUnqualifiedType()) { + if (Context.hasSameUnqualifiedType(Field->getType(), + castExpr->getType())) { Diag(TyR.getBegin(), diag::ext_typecheck_cast_to_union) << castExpr->getSourceRange(); break; @@ -3761,7 +3759,7 @@ Sema::CheckPointerTypesForAssignment(QualType lhsType, QualType rhsType) { rhptee = Context.getCanonicalType(rhptee); } while (lhptee->isPointerType() && rhptee->isPointerType()); - if (lhptee.getUnqualifiedType() == rhptee.getUnqualifiedType()) + if (Context.hasSameUnqualifiedType(lhptee, rhptee)) return IncompatibleNestedPointerQualifiers; } @@ -3791,7 +3789,7 @@ Sema::CheckBlockPointerTypesForAssignment(QualType lhsType, AssignConvertType ConvTy = Compatible; // For blocks we enforce that qualifiers are identical. - if (lhptee.getCVRQualifiers() != rhptee.getCVRQualifiers()) + if (lhptee.getLocalCVRQualifiers() != rhptee.getLocalCVRQualifiers()) ConvTy = CompatiblePointerDiscardsQualifiers; if (!Context.typesAreCompatible(lhptee, rhptee)) diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp index bdd47cc2bb3..3fcacfc9f32 100644 --- a/clang/lib/Sema/SemaExprCXX.cpp +++ b/clang/lib/Sema/SemaExprCXX.cpp @@ -1431,8 +1431,7 @@ QualType Sema::CheckPointerToMemberOperands( } } - if (Context.getCanonicalType(Class).getUnqualifiedType() != - Context.getCanonicalType(LType).getUnqualifiedType()) { + if (!Context.hasSameUnqualifiedType(Class, LType)) { CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false, /*DetectVirtual=*/false); // FIXME: Would it be useful to print full ambiguity paths, or is that diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp index 4746a2597e5..0f973d6d9ba 100644 --- a/clang/lib/Sema/SemaInit.cpp +++ b/clang/lib/Sema/SemaInit.cpp @@ -174,7 +174,8 @@ bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType, // copy-initialization where the cv-unqualified version of the // source type is the same class as, or a derived class of, the // class of the destination, constructors are considered. - if ((DeclTypeC.getUnqualifiedType() == InitTypeC.getUnqualifiedType()) || + if ((DeclTypeC.getLocalUnqualifiedType() + == InitTypeC.getLocalUnqualifiedType()) || IsDerivedFrom(InitTypeC, DeclTypeC)) { const CXXRecordDecl *RD = cast<CXXRecordDecl>(DeclType->getAs<RecordType>()->getDecl()); diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp index 4f261383ade..d45a1a8b92d 100644 --- a/clang/lib/Sema/SemaLookup.cpp +++ b/clang/lib/Sema/SemaLookup.cpp @@ -1576,8 +1576,7 @@ IsAcceptableNonMemberOperatorCandidate(FunctionDecl *Fn, if (T1->isEnumeralType()) { QualType ArgType = Proto->getArgType(0).getNonReferenceType(); - if (Context.getCanonicalType(T1).getUnqualifiedType() - == Context.getCanonicalType(ArgType).getUnqualifiedType()) + if (Context.hasSameUnqualifiedType(T1, ArgType)) return true; } @@ -1586,8 +1585,7 @@ IsAcceptableNonMemberOperatorCandidate(FunctionDecl *Fn, if (!T2.isNull() && T2->isEnumeralType()) { QualType ArgType = Proto->getArgType(1).getNonReferenceType(); - if (Context.getCanonicalType(T2).getUnqualifiedType() - == Context.getCanonicalType(ArgType).getUnqualifiedType()) + if (Context.hasSameUnqualifiedType(T2, ArgType)) return true; } diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index 56a878b694b..0ec0189ebf8 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -519,8 +519,6 @@ Sema::IsStandardConversion(Expr* From, QualType ToType, // cv-unqualified version of T. Otherwise, the type of the rvalue // is T (C++ 4.1p1). C++ can't get here with class types; in C, we // just strip the qualifiers because they don't matter. - - // FIXME: Doesn't see through to qualifiers behind a typedef! FromType = FromType.getUnqualifiedType(); } else if (FromType->isArrayType()) { // Array-to-pointer conversion (C++ 4.2) @@ -678,8 +676,9 @@ Sema::IsStandardConversion(Expr* From, QualType ToType, // a conversion. [...] CanonFrom = Context.getCanonicalType(FromType); CanonTo = Context.getCanonicalType(ToType); - if (CanonFrom.getUnqualifiedType() == CanonTo.getUnqualifiedType() && - CanonFrom.getCVRQualifiers() != CanonTo.getCVRQualifiers()) { + if (CanonFrom.getLocalUnqualifiedType() + == CanonTo.getLocalUnqualifiedType() && + CanonFrom.getLocalCVRQualifiers() != CanonTo.getLocalCVRQualifiers()) { FromType = ToType; CanonFrom = CanonTo; } @@ -756,8 +755,7 @@ bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) { // We found the type that we can promote to. If this is the // type we wanted, we have a promotion. Otherwise, no // promotion. - return Context.getCanonicalType(ToType).getUnqualifiedType() - == Context.getCanonicalType(PromoteTypes[Idx]).getUnqualifiedType(); + return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]); } } } @@ -864,7 +862,7 @@ BuildSimilarlyQualifiedPointerType(const PointerType *FromPtr, Qualifiers Quals = CanonFromPointee.getQualifiers(); // Exact qualifier match -> return the pointer type we're converting to. - if (CanonToPointee.getQualifiers() == Quals) { + if (CanonToPointee.getLocalQualifiers() == Quals) { // ToType is exactly what we need. Return it. if (!ToType.isNull()) return ToType; @@ -876,7 +874,8 @@ BuildSimilarlyQualifiedPointerType(const PointerType *FromPtr, // Just build a canonical type that has the right qualifiers. return Context.getPointerType( - Context.getQualifiedType(CanonToPointee.getUnqualifiedType(), Quals)); + Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), + Quals)); } static bool isNullPointerConstantForConversion(Expr *Expr, @@ -1348,8 +1347,7 @@ Sema::IsQualificationConversion(QualType FromType, QualType ToType) { // of types. If we unwrapped any pointers, and if FromType and // ToType have the same unqualified type (since we checked // qualifiers above), then this is a qualification conversion. - return UnwrappedAnyPointer && - FromType.getUnqualifiedType() == ToType.getUnqualifiedType(); + return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType); } /// \brief Given a function template or function, extract the function template @@ -1742,7 +1740,7 @@ Sema::CompareStandardConversionSequences(const StandardConversionSequence& SCS1, QualType T2 = QualType::getFromOpaquePtr(SCS2.ToTypePtr); T1 = Context.getCanonicalType(T1); T2 = Context.getCanonicalType(T2); - if (T1.getUnqualifiedType() == T2.getUnqualifiedType()) { + if (Context.hasSameUnqualifiedType(T1, T2)) { if (T2.isMoreQualifiedThan(T1)) return ImplicitConversionSequence::Better; else if (T1.isMoreQualifiedThan(T2)) @@ -1778,7 +1776,7 @@ Sema::CompareQualificationConversions(const StandardConversionSequence& SCS1, // If the types are the same, we won't learn anything by unwrapped // them. - if (T1.getUnqualifiedType() == T2.getUnqualifiedType()) + if (Context.hasSameUnqualifiedType(T1, T2)) return ImplicitConversionSequence::Indistinguishable; ImplicitConversionSequence::CompareKind Result @@ -1818,7 +1816,7 @@ Sema::CompareQualificationConversions(const StandardConversionSequence& SCS1, } // If the types after this point are equivalent, we're done. - if (T1.getUnqualifiedType() == T2.getUnqualifiedType()) + if (Context.hasSameUnqualifiedType(T1, T2)) break; } @@ -1933,8 +1931,8 @@ Sema::CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1, // -- binding of an expression of type C to a reference of type // B& is better than binding an expression of type C to a // reference of type A&, - if (FromType1.getUnqualifiedType() == FromType2.getUnqualifiedType() && - ToType1.getUnqualifiedType() != ToType2.getUnqualifiedType()) { + if (Context.hasSameUnqualifiedType(FromType1, FromType2) && + !Context.hasSameUnqualifiedType(ToType1, ToType2)) { if (IsDerivedFrom(ToType1, ToType2)) return ImplicitConversionSequence::Better; else if (IsDerivedFrom(ToType2, ToType1)) @@ -1944,8 +1942,8 @@ Sema::CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1, // -- binding of an expression of type B to a reference of type // A& is better than binding an expression of type C to a // reference of type A&, - if (FromType1.getUnqualifiedType() != FromType2.getUnqualifiedType() && - ToType1.getUnqualifiedType() == ToType2.getUnqualifiedType()) { + if (!Context.hasSameUnqualifiedType(FromType1, FromType2) && + Context.hasSameUnqualifiedType(ToType1, ToType2)) { if (IsDerivedFrom(FromType2, FromType1)) return ImplicitConversionSequence::Better; else if (IsDerivedFrom(FromType1, FromType2)) @@ -1992,8 +1990,8 @@ Sema::CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1, if (SCS1.CopyConstructor && SCS2.CopyConstructor && SCS1.Second == ICK_Derived_To_Base) { // -- conversion of C to B is better than conversion of C to A, - if (FromType1.getUnqualifiedType() == FromType2.getUnqualifiedType() && - ToType1.getUnqualifiedType() != ToType2.getUnqualifiedType()) { + if (Context.hasSameUnqualifiedType(FromType1, FromType2) && + !Context.hasSameUnqualifiedType(ToType1, ToType2)) { if (IsDerivedFrom(ToType1, ToType2)) return ImplicitConversionSequence::Better; else if (IsDerivedFrom(ToType2, ToType1)) @@ -2001,8 +1999,8 @@ Sema::CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1, } // -- conversion of B to A is better than conversion of C to A. - if (FromType1.getUnqualifiedType() != FromType2.getUnqualifiedType() && - ToType1.getUnqualifiedType() == ToType2.getUnqualifiedType()) { + if (!Context.hasSameUnqualifiedType(FromType1, FromType2) && + Context.hasSameUnqualifiedType(ToType1, ToType2)) { if (IsDerivedFrom(FromType2, FromType1)) return ImplicitConversionSequence::Better; else if (IsDerivedFrom(FromType1, FromType2)) @@ -2114,14 +2112,15 @@ Sema::TryObjectArgumentInitialization(Expr *From, CXXMethodDecl *Method) { // First check the qualifiers. We don't care about lvalue-vs-rvalue // with the implicit object parameter (C++ [over.match.funcs]p5). QualType FromTypeCanon = Context.getCanonicalType(FromType); - if (ImplicitParamType.getCVRQualifiers() != FromTypeCanon.getCVRQualifiers() && + if (ImplicitParamType.getCVRQualifiers() + != FromTypeCanon.getLocalCVRQualifiers() && !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) return ICS; // Check that we have either the same type or a derived type. It // affects the conversion rank. QualType ClassTypeCanon = Context.getCanonicalType(ClassType); - if (ClassTypeCanon == FromTypeCanon.getUnqualifiedType()) + if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) ICS.Standard.Second = ICK_Identity; else if (IsDerivedFrom(FromType, ClassType)) ICS.Standard.Second = ICK_Derived_To_Base; @@ -3079,7 +3078,7 @@ BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty, Ty = RefTy->getPointeeType(); // We don't care about qualifiers on the type. - Ty = Ty.getUnqualifiedType(); + Ty = Ty.getLocalUnqualifiedType(); // If we're dealing with an array type, decay to the pointer. if (Ty->isArrayType()) diff --git a/clang/lib/Sema/SemaStmt.cpp b/clang/lib/Sema/SemaStmt.cpp index e9061b8ac2a..d0f214fbd83 100644 --- a/clang/lib/Sema/SemaStmt.cpp +++ b/clang/lib/Sema/SemaStmt.cpp @@ -873,8 +873,7 @@ static bool IsReturnCopyElidable(ASTContext &Ctx, QualType RetType, if (!RetType->isRecordType()) return false; // ... the same cv-unqualified type as the function return type ... - if (Ctx.getCanonicalType(RetType).getUnqualifiedType() != - Ctx.getCanonicalType(ExprType).getUnqualifiedType()) + if (!Ctx.hasSameUnqualifiedType(RetType, ExprType)) return false; // ... the expression is the name of a non-volatile automatic object ... // We ignore parentheses here. diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp index 244bb37c37e..10594c728fb 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -354,8 +354,8 @@ static QualType getUnqualifiedArrayType(ASTContext &Context, QualType T, Qualifiers &Quals) { assert(T.isCanonical() && "Only operates on canonical types"); if (!isa<ArrayType>(T)) { - Quals = T.getQualifiers(); - return T.getUnqualifiedType(); + Quals = T.getLocalQualifiers(); + return T.getLocalUnqualifiedType(); } assert(!T.hasQualifiers() && "canonical array type has qualifiers!"); @@ -1440,16 +1440,16 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, // - If A is a cv-qualified type, the top level cv-qualifiers of A’s // type are ignored for type deduction. QualType CanonArgType = Context.getCanonicalType(ArgType); - if (CanonArgType.getCVRQualifiers()) - ArgType = CanonArgType.getUnqualifiedType(); + if (CanonArgType.getLocalCVRQualifiers()) + ArgType = CanonArgType.getLocalUnqualifiedType(); } } // C++0x [temp.deduct.call]p3: // If P is a cv-qualified type, the top level cv-qualifiers of P’s type // are ignored for type deduction. - if (CanonParamType.getCVRQualifiers()) - ParamType = CanonParamType.getUnqualifiedType(); + if (CanonParamType.getLocalCVRQualifiers()) + ParamType = CanonParamType.getLocalUnqualifiedType(); if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) { // [...] If P is a reference type, the type referred to by P is used // for type deduction. diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index d3dab4b8e13..2bee32aa0fc 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -2146,7 +2146,7 @@ template<typename Derived> QualType TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, QualifiedTypeLoc T) { - Qualifiers Quals = T.getType().getQualifiers(); + Qualifiers Quals = T.getType().getLocalQualifiers(); QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc()); if (Result.isNull()) @@ -5306,7 +5306,7 @@ TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, QualType T) { if (T->isDependentType() || T->isRecordType() || (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) { - assert(!T.hasQualifiers() && "Can't get cv-qualifiers here"); + assert(!T.hasLocalQualifiers() && "Can't get cv-qualifiers here"); return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, T.getTypePtr()); } |
