From 3d486f08cb9bd813181860371f793d692b8cbdb7 Mon Sep 17 00:00:00 2001 From: Ted Kremenek Date: Fri, 17 Jul 2009 01:01:15 +0000 Subject: [PATCH] Replace Type::getAsReferenceType() with Type::getAs(). llvm-svn: 76132 --- clang/include/clang/AST/Type.h | 3 +-- clang/lib/AST/ASTContext.cpp | 8 ++++---- clang/lib/AST/Type.cpp | 20 +------------------- clang/lib/Sema/SemaDeclCXX.cpp | 6 +++--- clang/lib/Sema/SemaExpr.cpp | 6 +++--- clang/lib/Sema/SemaNamedCast.cpp | 4 ++-- clang/lib/Sema/SemaOverload.cpp | 4 ++-- clang/lib/Sema/SemaTemplate.cpp | 4 ++-- clang/lib/Sema/SemaTemplateDeduction.cpp | 2 +- clang/lib/Sema/SemaType.cpp | 8 ++++---- 10 files changed, 23 insertions(+), 42 deletions(-) diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h index 3dee933fcfd6..d1bf6929f6f9 100644 --- a/clang/include/clang/AST/Type.h +++ b/clang/include/clang/AST/Type.h @@ -431,7 +431,6 @@ public: const FunctionType *getAsFunctionType() const; const FunctionNoProtoType *getAsFunctionNoProtoType() const; const FunctionProtoType *getAsFunctionProtoType() const; - const ReferenceType *getAsReferenceType() const; const LValueReferenceType *getAsLValueReferenceType() const; const RValueReferenceType *getAsRValueReferenceType() const; const MemberPointerType *getAsMemberPointerType() const; @@ -2105,7 +2104,7 @@ inline bool QualType::isAtLeastAsQualifiedAs(QualType Other) const { /// analysis, the expression designates the object or function /// denoted by the reference, and the expression is an lvalue. inline QualType QualType::getNonReferenceType() const { - if (const ReferenceType *RefType = (*this)->getAsReferenceType()) + if (const ReferenceType *RefType = (*this)->getAs()) return RefType->getPointeeType(); else return *this; diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index f30927c4ecb2..dcb18cb91d7f 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -447,7 +447,7 @@ unsigned ASTContext::getDeclAlignInBytes(const Decl *D) { if (const ValueDecl *VD = dyn_cast(D)) { QualType T = VD->getType(); - if (const ReferenceType* RT = T->getAsReferenceType()) { + if (const ReferenceType* RT = T->getAs()) { unsigned AS = RT->getPointeeType().getAddressSpace(); Align = Target.getPointerAlign(AS); } else if (!T->isIncompleteType() && !T->isFunctionType()) { @@ -779,7 +779,7 @@ void ASTRecordLayout::LayoutField(const FieldDecl *FD, unsigned FieldNo, FieldSize = 0; const ArrayType* ATy = Context.getAsArrayType(FD->getType()); FieldAlign = Context.getTypeAlign(ATy->getElementType()); - } else if (const ReferenceType *RT = FD->getType()->getAsReferenceType()) { + } else if (const ReferenceType *RT = FD->getType()->getAs()) { unsigned AS = RT->getPointeeType().getAddressSpace(); FieldSize = Context.Target.getPointerWidth(AS); FieldAlign = Context.Target.getPointerAlign(AS); @@ -3382,9 +3382,9 @@ QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) { // enough that they should be handled separately. // FIXME: Merging of lvalue and rvalue references is incorrect. C++ *really* // shouldn't be going through here! - if (const ReferenceType *RT = LHS->getAsReferenceType()) + if (const ReferenceType *RT = LHS->getAs()) LHS = RT->getPointeeType(); - if (const ReferenceType *RT = RHS->getAsReferenceType()) + if (const ReferenceType *RT = RHS->getAs()) RHS = RT->getPointeeType(); QualType LHSCan = getCanonicalType(LHS), diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp index 13d0cb03e8fd..28c3a8f42a28 100644 --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -305,24 +305,6 @@ QualType Type::getPointeeType() const { return QualType(); } -const ReferenceType *Type::getAsReferenceType() const { - // If this is directly a reference type, return it. - if (const ReferenceType *RTy = dyn_cast(this)) - return RTy; - - // If the canonical form of this type isn't the right kind, reject it. - if (!isa(CanonicalType)) { - // Look through type qualifiers - if (isa(CanonicalType.getUnqualifiedType())) - return CanonicalType.getUnqualifiedType()->getAsReferenceType(); - return 0; - } - - // If this is a typedef for a reference type, strip the typedef off without - // losing all typedef information. - return cast(getDesugaredType()); -} - const LValueReferenceType *Type::getAsLValueReferenceType() const { // If this is directly an lvalue reference type, return it. if (const LValueReferenceType *RTy = dyn_cast(this)) @@ -395,7 +377,7 @@ bool Type::isVariablyModifiedType() const { // correctly. if (const PointerType *PT = getAs()) return PT->getPointeeType()->isVariablyModifiedType(); - if (const ReferenceType *RT = getAsReferenceType()) + if (const ReferenceType *RT = getAs()) return RT->getPointeeType()->isVariablyModifiedType(); if (const MemberPointerType *PT = getAsMemberPointerType()) return PT->getPointeeType()->isVariablyModifiedType(); diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index 21daa8fc030d..d533e63c48b0 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -1751,7 +1751,7 @@ Sema::DeclPtrTy Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) { // virtual function that overrides a virtual function in a base class. QualType ClassType = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl)); - if (const ReferenceType *ConvTypeRef = ConvType->getAsReferenceType()) + if (const ReferenceType *ConvTypeRef = ConvType->getAs()) ConvType = ConvTypeRef->getPointeeType(); if (ConvType->isRecordType()) { ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType(); @@ -2548,7 +2548,7 @@ Sema::CheckReferenceInit(Expr *&Init, QualType DeclType, bool AllowExplicit, bool ForceRValue) { assert(DeclType->isReferenceType() && "Reference init needs a reference"); - QualType T1 = DeclType->getAsReferenceType()->getPointeeType(); + QualType T1 = DeclType->getAs()->getPointeeType(); QualType T2 = Init->getType(); // If the initializer is the address of an overloaded function, try @@ -3083,7 +3083,7 @@ VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType, BaseType = Ptr->getPointeeType(); Mode = 1; DK = diag::err_catch_incomplete_ptr; - } else if(const ReferenceType *Ref = BaseType->getAsReferenceType()) { + } else if(const ReferenceType *Ref = BaseType->getAs()) { // For the purpose of error recovery, we treat rvalue refs like lvalue refs. BaseType = Ref->getPointeeType(); Mode = 2; diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index a229791ea968..da5e6bad0341 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -1073,7 +1073,7 @@ Sema::BuildDeclarationNameExpr(SourceLocation Loc, NamedDecl *D, Ctx = FD->getDeclContext(); MemberType = FD->getType(); - if (const ReferenceType *RefType = MemberType->getAsReferenceType()) + if (const ReferenceType *RefType = MemberType->getAs()) MemberType = RefType->getPointeeType(); else if (!FD->isMutable()) { unsigned combinedQualifiers @@ -2177,7 +2177,7 @@ Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc, // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref] // FIXME: Handle address space modifiers QualType MemberType = FD->getType(); - if (const ReferenceType *Ref = MemberType->getAsReferenceType()) + if (const ReferenceType *Ref = MemberType->getAs()) MemberType = Ref->getPointeeType(); else { unsigned combinedQualifiers = @@ -3447,7 +3447,7 @@ Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) { // right-hand side type. The caller is responsible for adjusting // lhsType so that the resulting expression does not have reference // type. - if (const ReferenceType *lhsTypeRef = lhsType->getAsReferenceType()) { + if (const ReferenceType *lhsTypeRef = lhsType->getAs()) { if (Context.typesAreCompatible(lhsTypeRef->getPointeeType(), rhsType)) return Compatible; return Incompatible; diff --git a/clang/lib/Sema/SemaNamedCast.cpp b/clang/lib/Sema/SemaNamedCast.cpp index 4b58b3d0c7f2..1fdbcfe6a13c 100644 --- a/clang/lib/Sema/SemaNamedCast.cpp +++ b/clang/lib/Sema/SemaNamedCast.cpp @@ -604,7 +604,7 @@ TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType, return TSC_NotApplicable; } - const ReferenceType *DestReference = DestType->getAsReferenceType(); + const ReferenceType *DestReference = DestType->getAs(); if (!DestReference) { return TSC_NotApplicable; } @@ -829,7 +829,7 @@ CheckDynamicCast(Sema &Self, Expr *&SrcExpr, QualType DestType, QualType DestPointee; const PointerType *DestPointer = DestType->getAs(); - const ReferenceType *DestReference = DestType->getAsReferenceType(); + const ReferenceType *DestReference = DestType->getAs(); if (DestPointer) { DestPointee = DestPointer->getPointeeType(); } else if (DestReference) { diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index dc24a0384dd6..aef7f181e514 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -2704,7 +2704,7 @@ BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty, // Look through reference types; they aren't part of the type of an // expression for the purposes of conversions. - if (const ReferenceType *RefTy = Ty->getAsReferenceType()) + if (const ReferenceType *RefTy = Ty->getAs()) Ty = RefTy->getPointeeType(); // We don't care about qualifiers on the type. @@ -3675,7 +3675,7 @@ Sema::ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType, bool IsMember = false; if (const PointerType *ToTypePtr = ToType->getAs()) FunctionType = ToTypePtr->getPointeeType(); - else if (const ReferenceType *ToTypeRef = ToType->getAsReferenceType()) + else if (const ReferenceType *ToTypeRef = ToType->getAs()) FunctionType = ToTypeRef->getPointeeType(); else if (const MemberPointerType *MemTypePtr = ToType->getAsMemberPointerType()) { diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index 85d38671f103..9159cf12d5d5 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -1654,7 +1654,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, // represents a set of overloaded functions, the matching // function is selected from the set (13.4). (ParamType->isReferenceType() && - ParamType->getAsReferenceType()->getPointeeType()->isFunctionType()) || + ParamType->getAs()->getPointeeType()->isFunctionType()) || // -- For a non-type template-parameter of type pointer to // member function, no conversions apply. If the // template-argument represents a set of overloaded member @@ -1755,7 +1755,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, return false; } - if (const ReferenceType *ParamRefType = ParamType->getAsReferenceType()) { + if (const ReferenceType *ParamRefType = ParamType->getAs()) { // -- For a non-type template-parameter of type reference to // object, no conversions apply. The type referred to by the // reference may be more cv-qualified than the (otherwise diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp index b304751beb68..d47553858653 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -1282,7 +1282,7 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, // are ignored for type deduction. if (CanonParamType.getCVRQualifiers()) ParamType = CanonParamType.getUnqualifiedType(); - if (const ReferenceType *ParamRefType = ParamType->getAsReferenceType()) { + if (const ReferenceType *ParamRefType = ParamType->getAs()) { // [...] If P is a reference type, the type referred to by P is used // for type deduction. ParamType = ParamRefType->getPointeeType(); diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index ee4cd204b99a..d69227cc9424 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -301,7 +301,7 @@ QualType Sema::ConvertDeclSpecToType(const DeclSpec &DS, if (Result->isPointerType() || Result->isReferenceType()) { QualType EltTy = Result->isPointerType() ? Result->getAs()->getPointeeType() : - Result->getAsReferenceType()->getPointeeType(); + Result->getAs()->getPointeeType(); // If we have a pointer or reference, the pointee must have an object // incomplete type. @@ -1188,7 +1188,7 @@ bool Sema::CheckSpecifiedExceptionType(QualType T, const SourceRange &Range) { if (const PointerType* IT = T->getAs()) { T = IT->getPointeeType(); kind = 1; - } else if (const ReferenceType* IT = T->getAsReferenceType()) { + } else if (const ReferenceType* IT = T->getAs()) { T = IT->getPointeeType(); kind = 2; } else @@ -1285,7 +1285,7 @@ bool Sema::CheckExceptionSpecSubset(unsigned DiagID, unsigned NoteID, // Take one type from the subset. QualType CanonicalSubT = Context.getCanonicalType(*SubI); bool SubIsPointer = false; - if (const ReferenceType *RefTy = CanonicalSubT->getAsReferenceType()) + if (const ReferenceType *RefTy = CanonicalSubT->getAs()) CanonicalSubT = RefTy->getPointeeType(); if (const PointerType *PtrTy = CanonicalSubT->getAs()) { CanonicalSubT = PtrTy->getPointeeType(); @@ -1305,7 +1305,7 @@ bool Sema::CheckExceptionSpecSubset(unsigned DiagID, unsigned NoteID, QualType CanonicalSuperT = Context.getCanonicalType(*SuperI); // SubT must be SuperT or derived from it, or pointer or reference to // such types. - if (const ReferenceType *RefTy = CanonicalSuperT->getAsReferenceType()) + if (const ReferenceType *RefTy = CanonicalSuperT->getAs()) CanonicalSuperT = RefTy->getPointeeType(); if (SubIsPointer) { if (const PointerType *PtrTy = CanonicalSuperT->getAs())