From 8a286fbdb9618d6faea3f6a6c6b9efe370c73dc3 Mon Sep 17 00:00:00 2001 From: Ted Kremenek Date: Fri, 17 Jul 2009 17:50:17 +0000 Subject: [PATCH] Per offline discussion with Steve Naroff, add back Type::getAsXXXType() methods until Doug Gregor's Type smart pointer code lands (or more discussion occurs). These methods just call the new Type::getAs methods, so we still have reduced implementation redundancy. Having explicit getAsXXXType() methods makes it easier to set breakpoints in the debugger. llvm-svn: 76193 --- clang/include/clang/AST/ExprCXX.h | 2 +- clang/include/clang/AST/Type.h | 16 +++- .../clang/Analysis/PathSensitive/MemRegion.h | 2 +- clang/lib/AST/ASTContext.cpp | 34 +++---- clang/lib/AST/Decl.cpp | 12 +-- clang/lib/AST/DeclBase.cpp | 2 +- clang/lib/AST/DeclCXX.cpp | 22 ++--- clang/lib/AST/DeclPrinter.cpp | 6 +- clang/lib/AST/DeclarationName.cpp | 6 +- clang/lib/AST/Expr.cpp | 12 +-- clang/lib/AST/ExprCXX.cpp | 10 +- clang/lib/AST/ExprConstant.cpp | 8 +- clang/lib/AST/InheritViz.cpp | 2 +- clang/lib/AST/Type.cpp | 42 ++++++-- clang/lib/Analysis/BasicStore.cpp | 2 +- clang/lib/Analysis/CFRefCount.cpp | 6 +- clang/lib/Analysis/CheckNSError.cpp | 4 +- clang/lib/Analysis/GRExprEngine.cpp | 4 +- clang/lib/Analysis/RegionStore.cpp | 16 ++-- clang/lib/Analysis/Store.cpp | 6 +- clang/lib/CodeGen/CGBlocks.cpp | 2 +- clang/lib/CodeGen/CGCXX.cpp | 2 +- clang/lib/CodeGen/CGExpr.cpp | 6 +- clang/lib/CodeGen/CGExprAgg.cpp | 4 +- clang/lib/CodeGen/CGExprConstant.cpp | 4 +- clang/lib/CodeGen/CGExprScalar.cpp | 10 +- clang/lib/CodeGen/CGObjCMac.cpp | 6 +- clang/lib/CodeGen/CodeGenFunction.cpp | 4 +- clang/lib/CodeGen/CodeGenModule.cpp | 2 +- clang/lib/CodeGen/CodeGenTypes.cpp | 4 +- clang/lib/CodeGen/TargetABIInfo.cpp | 10 +- clang/lib/Frontend/PCHReader.cpp | 2 +- clang/lib/Frontend/RewriteBlocks.cpp | 14 +-- clang/lib/Frontend/RewriteObjC.cpp | 32 +++---- clang/lib/Sema/SemaCXXScopeSpec.cpp | 4 +- clang/lib/Sema/SemaChecking.cpp | 8 +- clang/lib/Sema/SemaDecl.cpp | 6 +- clang/lib/Sema/SemaDeclAttr.cpp | 20 ++-- clang/lib/Sema/SemaDeclCXX.cpp | 54 +++++------ clang/lib/Sema/SemaExpr.cpp | 96 +++++++++---------- clang/lib/Sema/SemaExprCXX.cpp | 34 +++---- clang/lib/Sema/SemaExprObjC.cpp | 2 +- clang/lib/Sema/SemaInherit.cpp | 6 +- clang/lib/Sema/SemaInit.cpp | 20 ++-- clang/lib/Sema/SemaLookup.cpp | 10 +- clang/lib/Sema/SemaNamedCast.cpp | 36 +++---- clang/lib/Sema/SemaOverload.cpp | 90 ++++++++--------- clang/lib/Sema/SemaStmt.cpp | 4 +- clang/lib/Sema/SemaTemplate.cpp | 16 ++-- clang/lib/Sema/SemaTemplateDeduction.cpp | 12 +-- clang/lib/Sema/SemaType.cpp | 36 +++---- 51 files changed, 401 insertions(+), 369 deletions(-) diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h index ccfab7418a32..176786601719 100644 --- a/clang/include/clang/AST/ExprCXX.h +++ b/clang/include/clang/AST/ExprCXX.h @@ -711,7 +711,7 @@ public: QualType getAllocatedType() const { assert(getType()->isPointerType()); - return getType()->getAs()->getPointeeType(); + return getType()->getAsPointerType()->getPointeeType(); } FunctionDecl *getOperatorNew() const { return OperatorNew; } diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h index 5099c61819e9..b88cb841e80a 100644 --- a/clang/include/clang/AST/Type.h +++ b/clang/include/clang/AST/Type.h @@ -431,6 +431,14 @@ public: const FunctionType *getAsFunctionType() const; const FunctionNoProtoType *getAsFunctionNoProtoType() const; const FunctionProtoType *getAsFunctionProtoType() const; + const PointerType *getAsPointerType() const; + const BlockPointerType *getAsBlockPointerType() const; + const ReferenceType *getAsReferenceType() const; + const LValueReferenceType *getAsLValueReferenceType() const; + const RValueReferenceType *getAsRValueReferenceType() const; + const MemberPointerType *getAsMemberPointerType() const; + const TagType *getAsTagType() const; + const RecordType *getAsRecordType() const; const RecordType *getAsStructureType() const; /// NOTE: getAs*ArrayType are methods on ASTContext. const TypedefType *getAsTypedefType() const; @@ -2099,7 +2107,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)->getAs()) + if (const ReferenceType *RefType = (*this)->getAsReferenceType()) return RefType->getPointeeType(); else return *this; @@ -2109,7 +2117,7 @@ inline const TypedefType* Type::getAsTypedefType() const { return dyn_cast(this); } inline const ObjCInterfaceType *Type::getAsPointerToObjCInterfaceType() const { - if (const PointerType *PT = getAs()) + if (const PointerType *PT = getAsPointerType()) return PT->getPointeeType()->getAsObjCInterfaceType(); return 0; } @@ -2138,7 +2146,7 @@ inline bool Type::isRValueReferenceType() const { return isa(CanonicalType.getUnqualifiedType()); } inline bool Type::isFunctionPointerType() const { - if (const PointerType* T = getAs()) + if (const PointerType* T = getAsPointerType()) return T->getPointeeType()->isFunctionType(); else return false; @@ -2147,7 +2155,7 @@ inline bool Type::isMemberPointerType() const { return isa(CanonicalType.getUnqualifiedType()); } inline bool Type::isMemberFunctionPointerType() const { - if (const MemberPointerType* T = getAs()) + if (const MemberPointerType* T = getAsMemberPointerType()) return T->getPointeeType()->isFunctionType(); else return false; diff --git a/clang/include/clang/Analysis/PathSensitive/MemRegion.h b/clang/include/clang/Analysis/PathSensitive/MemRegion.h index 46d01134226e..7f8c5c29037f 100644 --- a/clang/include/clang/Analysis/PathSensitive/MemRegion.h +++ b/clang/include/clang/Analysis/PathSensitive/MemRegion.h @@ -357,7 +357,7 @@ public: } QualType getValueType(ASTContext&) const { - const PointerType* PTy = LValueType->getAs(); + const PointerType* PTy = LValueType->getAsPointerType(); assert(PTy); return PTy->getPointeeType(); } diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index f37ffddc12f7..b43aadb62e4a 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->getAs()) { + if (const ReferenceType* RT = T->getAsReferenceType()) { 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()->getAs()) { + } else if (const ReferenceType *RT = FD->getType()->getAsReferenceType()) { unsigned AS = RT->getPointeeType().getAddressSpace(); FieldSize = Context.Target.getPointerWidth(AS); FieldAlign = Context.Target.getPointerAlign(AS); @@ -1092,7 +1092,7 @@ QualType ASTContext::getObjCGCQualType(QualType T, return T; if (T->isPointerType()) { - QualType Pointee = T->getAs()->getPointeeType(); + QualType Pointee = T->getAsPointerType()->getPointeeType(); if (Pointee->isAnyPointerType()) { QualType ResultType = getObjCGCQualType(Pointee, GCAttr); return getPointerType(ResultType); @@ -2462,7 +2462,7 @@ QualType ASTContext::getCFConstantStringType() { } void ASTContext::setCFConstantStringType(QualType T) { - const RecordType *Rec = T->getAs(); + const RecordType *Rec = T->getAsRecordType(); assert(Rec && "Invalid CFConstantStringType"); CFConstantStringTypeDecl = Rec->getDecl(); } @@ -2498,7 +2498,7 @@ QualType ASTContext::getObjCFastEnumerationStateType() } void ASTContext::setObjCFastEnumerationStateType(QualType T) { - const RecordType *Rec = T->getAs(); + const RecordType *Rec = T->getAsRecordType(); assert(Rec && "Invalid ObjCFAstEnumerationStateType"); ObjCFastEnumerationStateTypeDecl = Rec->getDecl(); } @@ -2779,7 +2779,7 @@ void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, return; } - if (const PointerType *PT = T->getAs()) { + if (const PointerType *PT = T->getAsPointerType()) { QualType PointeeTy = PT->getPointeeType(); bool isReadOnly = false; // For historical/compatibility reasons, the read-only qualifier of the @@ -2794,8 +2794,8 @@ void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, } else if (OutermostType) { QualType P = PointeeTy; - while (P->getAs()) - P = P->getAs()->getPointeeType(); + while (P->getAsPointerType()) + P = P->getAsPointerType()->getPointeeType(); if (P.isConstQualified()) { isReadOnly = true; S += 'r'; @@ -2866,7 +2866,7 @@ void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, return; } - if (const RecordType *RTy = T->getAs()) { + if (const RecordType *RTy = T->getAsRecordType()) { RecordDecl *RDecl = RTy->getDecl(); S += RDecl->isUnion() ? '(' : '{'; // Anonymous structures print as '?' @@ -3035,7 +3035,7 @@ void ASTContext::setObjCSelType(QualType T) { TypedefDecl *TD = TT->getDecl(); // typedef struct objc_selector *SEL; - const PointerType *ptr = TD->getUnderlyingType()->getAs(); + const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType(); if (!ptr) return; const RecordType *rec = ptr->getPointeeType()->getAsStructureType(); @@ -3159,7 +3159,7 @@ QualType::GCAttrTypes ASTContext::getObjCGCAttrKind(const QualType &Ty) const { if (Ty->isObjCObjectPointerType()) GCAttrs = QualType::Strong; else if (Ty->isPointerType()) - return getObjCGCAttrKind(Ty->getAs()->getPointeeType()); + return getObjCGCAttrKind(Ty->getAsPointerType()->getPointeeType()); } // Non-pointers have none gc'able attribute regardless of the attribute // set on them. @@ -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->getAs()) + if (const ReferenceType *RT = LHS->getAsReferenceType()) LHS = RT->getPointeeType(); - if (const ReferenceType *RT = RHS->getAs()) + if (const ReferenceType *RT = RHS->getAsReferenceType()) RHS = RT->getPointeeType(); QualType LHSCan = getCanonicalType(LHS), @@ -3519,8 +3519,8 @@ QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) { case Type::Pointer: { // Merge two pointer types, while trying to preserve typedef info - QualType LHSPointee = LHS->getAs()->getPointeeType(); - QualType RHSPointee = RHS->getAs()->getPointeeType(); + QualType LHSPointee = LHS->getAsPointerType()->getPointeeType(); + QualType RHSPointee = RHS->getAsPointerType()->getPointeeType(); QualType ResultType = mergeTypes(LHSPointee, RHSPointee); if (ResultType.isNull()) return QualType(); if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) @@ -3532,8 +3532,8 @@ QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) { case Type::BlockPointer: { // Merge two block pointer types, while trying to preserve typedef info - QualType LHSPointee = LHS->getAs()->getPointeeType(); - QualType RHSPointee = RHS->getAs()->getPointeeType(); + QualType LHSPointee = LHS->getAsBlockPointerType()->getPointeeType(); + QualType RHSPointee = RHS->getAsBlockPointerType()->getPointeeType(); QualType ResultType = mergeTypes(LHSPointee, RHSPointee); if (ResultType.isNull()) return QualType(); if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp index a9f258146e5e..728724f1b3d4 100644 --- a/clang/lib/AST/Decl.cpp +++ b/clang/lib/AST/Decl.cpp @@ -157,7 +157,7 @@ bool FieldDecl::isAnonymousStructOrUnion() const { if (!isImplicit() || getDeclName()) return false; - if (const RecordType *Record = getType()->getAs()) + if (const RecordType *Record = getType()->getAsRecordType()) return Record->getDecl()->isAnonymousStructOrUnion(); return false; @@ -704,24 +704,24 @@ SourceRange TagDecl::getSourceRange() const { } void TagDecl::startDefinition() { - TagType *TagT = const_cast(TypeForDecl->getAs()); + TagType *TagT = const_cast(TypeForDecl->getAsTagType()); TagT->decl.setPointer(this); - TagT->getAs()->decl.setInt(1); + TagT->getAsTagType()->decl.setInt(1); } void TagDecl::completeDefinition() { assert((!TypeForDecl || - TypeForDecl->getAs()->decl.getPointer() == this) && + TypeForDecl->getAsTagType()->decl.getPointer() == this) && "Attempt to redefine a tag definition?"); IsDefinition = true; - TagType *TagT = const_cast(TypeForDecl->getAs()); + TagType *TagT = const_cast(TypeForDecl->getAsTagType()); TagT->decl.setPointer(this); TagT->decl.setInt(0); } TagDecl* TagDecl::getDefinition(ASTContext& C) const { QualType T = C.getTypeDeclType(const_cast(this)); - TagDecl* D = cast(T->getAs()->getDecl()); + TagDecl* D = cast(T->getAsTagType()->getDecl()); return D->isDefinition() ? D : 0; } diff --git a/clang/lib/AST/DeclBase.cpp b/clang/lib/AST/DeclBase.cpp index 2d276614f227..96ba19b9a6b9 100644 --- a/clang/lib/AST/DeclBase.cpp +++ b/clang/lib/AST/DeclBase.cpp @@ -473,7 +473,7 @@ DeclContext *DeclContext::getPrimaryContext() { if (DeclKind >= Decl::TagFirst && DeclKind <= Decl::TagLast) { // If this is a tag type that has a definition or is currently // being defined, that definition is our primary context. - if (const TagType *TagT =cast(this)->TypeForDecl->getAs()) + if (const TagType *TagT =cast(this)->TypeForDecl->getAsTagType()) if (TagT->isBeingDefined() || (TagT->getDecl() && TagT->getDecl()->isDefinition())) return TagT->getDecl(); diff --git a/clang/lib/AST/DeclCXX.cpp b/clang/lib/AST/DeclCXX.cpp index f420da14e455..57ac611b2ca2 100644 --- a/clang/lib/AST/DeclCXX.cpp +++ b/clang/lib/AST/DeclCXX.cpp @@ -81,7 +81,7 @@ CXXRecordDecl::setBases(ASTContext &C, if (BaseType->isDependentType()) continue; CXXRecordDecl *BaseClassDecl - = cast(BaseType->getAs()->getDecl()); + = cast(BaseType->getAsRecordType()->getDecl()); if (Base->isVirtual()) hasDirectVirtualBase = true; for (CXXRecordDecl::base_class_iterator VBase = @@ -125,7 +125,7 @@ CXXRecordDecl::setBases(ASTContext &C, for (int i = 0; i < vbaseCount; i++) { QualType QT = UniqueVbases[i]->getType(); CXXRecordDecl *VBaseClassDecl - = cast(QT->getAs()->getDecl()); + = cast(QT->getAsRecordType()->getDecl()); this->VBases[i] = *new CXXBaseSpecifier( VBaseClassDecl->getSourceRange(), true, @@ -185,7 +185,7 @@ bool CXXRecordDecl::hasConstCopyAssignment(ASTContext &Context) const { continue; bool AcceptsConst = true; QualType ArgType = FnType->getArgType(0); - if (const LValueReferenceType *Ref = ArgType->getAs()) { + if (const LValueReferenceType *Ref = ArgType->getAsLValueReferenceType()) { ArgType = Ref->getPointeeType(); // Is it a non-const lvalue reference? if (!ArgType.isConstQualified()) @@ -237,7 +237,7 @@ void CXXRecordDecl::addedAssignmentOperator(ASTContext &Context, assert(FnType && "Overloaded operator has no proto function type."); assert(FnType->getNumArgs() == 1 && !FnType->isVariadic()); QualType ArgType = FnType->getArgType(0); - if (const LValueReferenceType *Ref = ArgType->getAs()) + if (const LValueReferenceType *Ref = ArgType->getAsLValueReferenceType()) ArgType = Ref->getPointeeType(); ArgType = ArgType.getUnqualifiedType(); @@ -433,7 +433,7 @@ CXXConstructorDecl::isCopyConstructor(ASTContext &Context, // Do we have a reference type? Rvalue references don't count. const LValueReferenceType *ParamRefType = - Param->getType()->getAs(); + Param->getType()->getAsLValueReferenceType(); if (!ParamRefType) return false; @@ -503,7 +503,7 @@ CXXDestructorDecl::setBaseOrMemberDestructions(ASTContext &C) { while (const ArrayType *AT = C.getAsArrayType(FieldType)) FieldType = AT->getElementType(); - if (FieldType->getAs()) { + if (FieldType->getAsRecordType()) { CXXBaseOrMemberInitializer *Member = new CXXBaseOrMemberInitializer((*Field), 0, 0, SourceLocation()); AllToDestruct.push_back(Member); @@ -535,12 +535,12 @@ CXXConstructorDecl::setBaseOrMemberInitializers( for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(), E = ClassDecl->vbases_end(); VBase != E; ++VBase) { - const Type * T = VBase->getType()->getAs(); + const Type * T = VBase->getType()->getAsRecordType(); unsigned int i = 0; for (i = 0; i < NumInitializers; i++) { CXXBaseOrMemberInitializer *Member = Initializers[i]; if (Member->isBaseInitializer() && - Member->getBaseClass()->getAs() == T) { + Member->getBaseClass()->getAsRecordType() == T) { AllToInit.push_back(Member); break; } @@ -557,12 +557,12 @@ CXXConstructorDecl::setBaseOrMemberInitializers( // Virtuals are in the virtual base list and already constructed. if (Base->isVirtual()) continue; - const Type * T = Base->getType()->getAs(); + const Type * T = Base->getType()->getAsRecordType(); unsigned int i = 0; for (i = 0; i < NumInitializers; i++) { CXXBaseOrMemberInitializer *Member = Initializers[i]; if (Member->isBaseInitializer() && - Member->getBaseClass()->getAs() == T) { + Member->getBaseClass()->getAsRecordType() == T) { AllToInit.push_back(Member); break; } @@ -589,7 +589,7 @@ CXXConstructorDecl::setBaseOrMemberInitializers( while (const ArrayType *AT = C.getAsArrayType(FieldType)) FieldType = AT->getElementType(); - if (FieldType->getAs()) { + if (FieldType->getAsRecordType()) { CXXBaseOrMemberInitializer *Member = new CXXBaseOrMemberInitializer((*Field), 0, 0, SourceLocation()); AllToInit.push_back(Member); diff --git a/clang/lib/AST/DeclPrinter.cpp b/clang/lib/AST/DeclPrinter.cpp index 1711a7cf5633..84ae72977e6e 100644 --- a/clang/lib/AST/DeclPrinter.cpp +++ b/clang/lib/AST/DeclPrinter.cpp @@ -90,7 +90,7 @@ static QualType GetBaseType(QualType T) { while (!BaseType->isSpecifierType()) { if (isa(BaseType)) break; - else if (const PointerType* PTy = BaseType->getAs()) + else if (const PointerType* PTy = BaseType->getAsPointerType()) BaseType = PTy->getPointeeType(); else if (const ArrayType* ATy = dyn_cast(BaseType)) BaseType = ATy->getElementType(); @@ -353,7 +353,7 @@ void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) { } else // FIXME. skip dependent types for now. if (const RecordType *RT = - BMInitializer->getBaseClass()->getAs()) { + BMInitializer->getBaseClass()->getAsRecordType()) { const CXXRecordDecl *BaseDecl = cast(RT->getDecl()); Out << BaseDecl->getNameAsString(); @@ -394,7 +394,7 @@ void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) { } else // FIXME. skip dependent types for now. if (const RecordType *RT = - BMInitializer->getBaseClass()->getAs()) { + BMInitializer->getBaseClass()->getAsRecordType()) { const CXXRecordDecl *BaseDecl = cast(RT->getDecl()); Proto += "~"; diff --git a/clang/lib/AST/DeclarationName.cpp b/clang/lib/AST/DeclarationName.cpp index a55b363a0d4c..a17abde77730 100644 --- a/clang/lib/AST/DeclarationName.cpp +++ b/clang/lib/AST/DeclarationName.cpp @@ -135,7 +135,7 @@ std::string DeclarationName::getAsString() const { case CXXConstructorName: { QualType ClassType = getCXXNameType(); - if (const RecordType *ClassRec = ClassType->getAs()) + if (const RecordType *ClassRec = ClassType->getAsRecordType()) return ClassRec->getDecl()->getNameAsString(); return ClassType.getAsString(); } @@ -143,7 +143,7 @@ std::string DeclarationName::getAsString() const { case CXXDestructorName: { std::string Result = "~"; QualType Type = getCXXNameType(); - if (const RecordType *Rec = Type->getAs()) + if (const RecordType *Rec = Type->getAsRecordType()) Result += Rec->getDecl()->getNameAsString(); else Result += Type.getAsString(); @@ -170,7 +170,7 @@ std::string DeclarationName::getAsString() const { case CXXConversionFunctionName: { std::string Result = "operator "; QualType Type = getCXXNameType(); - if (const RecordType *Rec = Type->getAs()) + if (const RecordType *Rec = Type->getAsRecordType()) Result += Rec->getDecl()->getNameAsString(); else Result += Type.getAsString(); diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp index 54739780bec0..0a6d9fe128e2 100644 --- a/clang/lib/AST/Expr.cpp +++ b/clang/lib/AST/Expr.cpp @@ -287,9 +287,9 @@ unsigned CallExpr::isBuiltinCall(ASTContext &Context) const { QualType CallExpr::getCallReturnType() const { QualType CalleeType = getCallee()->getType(); - if (const PointerType *FnTypePtr = CalleeType->getAs()) + if (const PointerType *FnTypePtr = CalleeType->getAsPointerType()) CalleeType = FnTypePtr->getPointeeType(); - else if (const BlockPointerType *BPT = CalleeType->getAs()) + else if (const BlockPointerType *BPT = CalleeType->getAsBlockPointerType()) CalleeType = BPT->getPointeeType(); const FunctionType *FnType = CalleeType->getAsFunctionType(); @@ -438,7 +438,7 @@ Expr *InitListExpr::updateInit(unsigned Init, Expr *expr) { /// getFunctionType - Return the underlying function type for this block. /// const FunctionType *BlockExpr::getFunctionType() const { - return getType()->getAs()-> + return getType()->getAsBlockPointerType()-> getPointeeType()->getAsFunctionType(); } @@ -923,7 +923,7 @@ Expr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const { if (CT->isIncompleteType()) return MLV_IncompleteType; - if (const RecordType *r = CT->getAs()) { + if (const RecordType *r = CT->getAsRecordType()) { if (r->hasConstFields()) return MLV_ConstQualified; } @@ -999,7 +999,7 @@ bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const { QualType T = VD->getType(); // dereferencing to an object pointer is always a gc'able candidate if (T->isPointerType() && - T->getAs()->getPointeeType()->isObjCObjectPointerType()) + T->getAsPointerType()->getPointeeType()->isObjCObjectPointerType()) return true; } @@ -1427,7 +1427,7 @@ bool Expr::isNullPointerConstant(ASTContext &Ctx) const if (const ExplicitCastExpr *CE = dyn_cast(this)) { if (!Ctx.getLangOptions().CPlusPlus) { // Check that it is a cast to void*. - if (const PointerType *PT = CE->getType()->getAs()) { + if (const PointerType *PT = CE->getType()->getAsPointerType()) { QualType Pointee = PT->getPointeeType(); if (Pointee.getCVRQualifiers() == 0 && Pointee->isVoidType() && // to void* diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp index d5cfef23f839..399c30255a8f 100644 --- a/clang/lib/AST/ExprCXX.cpp +++ b/clang/lib/AST/ExprCXX.cpp @@ -219,28 +219,28 @@ bool UnaryTypeTraitExpr::EvaluateTrait() const { case UTT_IsPOD: return QueriedType->isPODType(); case UTT_IsClass: // Fallthrough case UTT_IsUnion: - if (const RecordType *Record = QueriedType->getAs()) { + if (const RecordType *Record = QueriedType->getAsRecordType()) { bool Union = Record->getDecl()->isUnion(); return UTT == UTT_IsUnion ? Union : !Union; } return false; case UTT_IsEnum: return QueriedType->isEnumeralType(); case UTT_IsPolymorphic: - if (const RecordType *Record = QueriedType->getAs()) { + if (const RecordType *Record = QueriedType->getAsRecordType()) { // Type traits are only parsed in C++, so we've got CXXRecords. return cast(Record->getDecl())->isPolymorphic(); } return false; case UTT_IsAbstract: - if (const RecordType *RT = QueriedType->getAs()) + if (const RecordType *RT = QueriedType->getAsRecordType()) return cast(RT->getDecl())->isAbstract(); return false; case UTT_HasTrivialConstructor: - if (const RecordType *RT = QueriedType->getAs()) + if (const RecordType *RT = QueriedType->getAsRecordType()) return cast(RT->getDecl())->hasTrivialConstructor(); return false; case UTT_HasTrivialDestructor: - if (const RecordType *RT = QueriedType->getAs()) + if (const RecordType *RT = QueriedType->getAsRecordType()) return cast(RT->getDecl())->hasTrivialDestructor(); return false; } diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index d01130372cea..2c29347c519c 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -222,7 +222,7 @@ APValue LValueExprEvaluator::VisitMemberExpr(MemberExpr *E) { if (E->isArrow()) { if (!EvaluatePointer(E->getBase(), result, Info)) return APValue(); - Ty = E->getBase()->getType()->getAs()->getPointeeType(); + Ty = E->getBase()->getType()->getAsPointerType()->getPointeeType(); } else { result = Visit(E->getBase()); if (result.isUninit()) @@ -230,7 +230,7 @@ APValue LValueExprEvaluator::VisitMemberExpr(MemberExpr *E) { Ty = E->getBase()->getType(); } - RecordDecl *RD = Ty->getAs()->getDecl(); + RecordDecl *RD = Ty->getAsRecordType()->getDecl(); const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD); FieldDecl *FD = dyn_cast(E->getMemberDecl()); @@ -351,7 +351,7 @@ APValue PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { if (!EvaluateInteger(IExp, AdditionalOffset, Info)) return APValue(); - QualType PointeeType = PExp->getType()->getAs()->getPointeeType(); + QualType PointeeType = PExp->getType()->getAsPointerType()->getPointeeType(); uint64_t SizeOfPointee; // Explicitly handle GNU void* and function pointer arithmetic extensions. @@ -1029,7 +1029,7 @@ bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { if (E->getOpcode() == BinaryOperator::Sub) { const QualType Type = E->getLHS()->getType(); - const QualType ElementType = Type->getAs()->getPointeeType(); + const QualType ElementType = Type->getAsPointerType()->getPointeeType(); uint64_t D = LHSValue.getLValueOffset() - RHSValue.getLValueOffset(); if (!ElementType->isVoidType() && !ElementType->isFunctionType()) diff --git a/clang/lib/AST/InheritViz.cpp b/clang/lib/AST/InheritViz.cpp index 3e5dd1a53ff2..1188ba5860b4 100644 --- a/clang/lib/AST/InheritViz.cpp +++ b/clang/lib/AST/InheritViz.cpp @@ -90,7 +90,7 @@ void InheritanceHierarchyWriter::WriteNode(QualType Type, bool FromVirtual) { // Display the base classes. const CXXRecordDecl *Decl - = static_cast(Type->getAs()->getDecl()); + = static_cast(Type->getAsRecordType()->getDecl()); for (CXXRecordDecl::base_class_const_iterator Base = Decl->bases_begin(); Base != Decl->bases_end(); ++Base) { QualType CanonBaseType = Context.getCanonicalType(Base->getType()); diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp index 6114dba1486c..2f66454aadea 100644 --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -192,23 +192,23 @@ bool Type::isDerivedType() const { } bool Type::isClassType() const { - if (const RecordType *RT = getAs()) + if (const RecordType *RT = getAsRecordType()) return RT->getDecl()->isClass(); return false; } bool Type::isStructureType() const { - if (const RecordType *RT = getAs()) + if (const RecordType *RT = getAsRecordType()) return RT->getDecl()->isStruct(); return false; } bool Type::isVoidPointerType() const { - if (const PointerType *PT = getAs()) + if (const PointerType *PT = getAsPointerType()) return PT->getPointeeType()->isVoidType(); return false; } bool Type::isUnionType() const { - if (const RecordType *RT = getAs()) + if (const RecordType *RT = getAsRecordType()) return RT->getDecl()->isUnion(); return false; } @@ -296,11 +296,11 @@ const FunctionProtoType *Type::getAsFunctionProtoType() const { } QualType Type::getPointeeType() const { - if (const PointerType *PT = getAs()) + if (const PointerType *PT = getAsPointerType()) return PT->getPointeeType(); if (const ObjCObjectPointerType *OPT = getAsObjCObjectPointerType()) return OPT->getPointeeType(); - if (const BlockPointerType *BPT = getAs()) + if (const BlockPointerType *BPT = getAsBlockPointerType()) return BPT->getPointeeType(); return QualType(); } @@ -321,11 +321,11 @@ bool Type::isVariablyModifiedType() const { // Also, C++ references and member pointers can point to a variably modified // type, where VLAs appear as an extension to C++, and should be treated // correctly. - if (const PointerType *PT = getAs()) + if (const PointerType *PT = getAsPointerType()) return PT->getPointeeType()->isVariablyModifiedType(); - if (const ReferenceType *RT = getAs()) + if (const ReferenceType *RT = getAsReferenceType()) return RT->getPointeeType()->isVariablyModifiedType(); - if (const MemberPointerType *PT = getAs()) + if (const MemberPointerType *PT = getAsMemberPointerType()) return PT->getPointeeType()->isVariablyModifiedType(); // A function can return a variably modified type @@ -338,6 +338,30 @@ bool Type::isVariablyModifiedType() const { return false; } +const PointerType *Type::getAsPointerType() const { + return getAs(); +} +const BlockPointerType *Type::getAsBlockPointerType() const { + return getAs(); +} +const ReferenceType *Type::getAsReferenceType() const { + return getAs(); +} +const LValueReferenceType *Type::getAsLValueReferenceType() const { + return getAs(); +} +const RValueReferenceType *Type::getAsRValueReferenceType() const { + return getAs(); +} +const MemberPointerType *Type::getAsMemberPointerType() const { + return getAs(); +} +const TagType *Type::getAsTagType() const { + return getAs(); +} +const RecordType *Type::getAsRecordType() const { + return getAs(); +} const RecordType *Type::getAsStructureType() const { // If this is directly a structure type, return it. if (const RecordType *RT = dyn_cast(this)) { diff --git a/clang/lib/Analysis/BasicStore.cpp b/clang/lib/Analysis/BasicStore.cpp index 99bfac2f50ae..7aa63c1c6301 100644 --- a/clang/lib/Analysis/BasicStore.cpp +++ b/clang/lib/Analysis/BasicStore.cpp @@ -251,7 +251,7 @@ SVal BasicStoreManager::getLValueElement(const GRState *state, static bool isHigherOrderRawPtr(QualType T, ASTContext &C) { bool foundPointer = false; while (1) { - const PointerType *PT = T->getAs(); + const PointerType *PT = T->getAsPointerType(); if (!PT) { if (!foundPointer) return false; diff --git a/clang/lib/Analysis/CFRefCount.cpp b/clang/lib/Analysis/CFRefCount.cpp index 1fa3e57af0c3..3d2e3ac9a89a 100644 --- a/clang/lib/Analysis/CFRefCount.cpp +++ b/clang/lib/Analysis/CFRefCount.cpp @@ -248,7 +248,7 @@ static bool isRefType(QualType RetTy, const char* prefix, return false; // Is the type void*? - const PointerType* PT = RetTy->getAs(); + const PointerType* PT = RetTy->getAsPointerType(); if (!(PT->getPointeeType().getUnqualifiedType() == Ctx->VoidTy)) return false; @@ -1250,7 +1250,7 @@ RetainSummaryManager::updateSummaryFromAnnotations(RetainSummary &Summ, Summ.setRetEffect(RetEffect::MakeOwned(RetEffect::CF, true)); } } - else if (RetTy->getAs()) { + else if (RetTy->getAsPointerType()) { if (FD->getAttr()) { Summ.setRetEffect(RetEffect::MakeOwned(RetEffect::CF, true)); } @@ -1276,7 +1276,7 @@ RetainSummaryManager::updateSummaryFromAnnotations(RetainSummary &Summ, } if (!isTrackedLoc) - isTrackedLoc = MD->getResultType()->getAs() != NULL; + isTrackedLoc = MD->getResultType()->getAsPointerType() != NULL; if (isTrackedLoc && MD->getAttr()) Summ.setRetEffect(RetEffect::MakeOwned(RetEffect::CF, true)); diff --git a/clang/lib/Analysis/CheckNSError.cpp b/clang/lib/Analysis/CheckNSError.cpp index 4e8ba01e3e24..c1382d03774c 100644 --- a/clang/lib/Analysis/CheckNSError.cpp +++ b/clang/lib/Analysis/CheckNSError.cpp @@ -161,7 +161,7 @@ NSErrorCheck::CheckSignature(FunctionDecl& F, QualType& ResultTy, bool NSErrorCheck::CheckNSErrorArgument(QualType ArgTy) { - const PointerType* PPT = ArgTy->getAs(); + const PointerType* PPT = ArgTy->getAsPointerType(); if (!PPT) return false; @@ -182,7 +182,7 @@ bool NSErrorCheck::CheckNSErrorArgument(QualType ArgTy) { bool NSErrorCheck::CheckCFErrorArgument(QualType ArgTy) { - const PointerType* PPT = ArgTy->getAs(); + const PointerType* PPT = ArgTy->getAsPointerType(); if (!PPT) return false; const TypedefType* TT = PPT->getPointeeType()->getAsTypedefType(); diff --git a/clang/lib/Analysis/GRExprEngine.cpp b/clang/lib/Analysis/GRExprEngine.cpp index b4bec5487757..f83e92acb3a6 100644 --- a/clang/lib/Analysis/GRExprEngine.cpp +++ b/clang/lib/Analysis/GRExprEngine.cpp @@ -1274,7 +1274,7 @@ static bool EvalOSAtomicCompareAndSwap(ExplodedNodeSet& Dst, return false; Expr *theValueExpr = CE->getArg(2); - const PointerType *theValueType = theValueExpr->getType()->getAs(); + const PointerType *theValueType = theValueExpr->getType()->getAsPointerType(); // theValueType not a pointer? if (!theValueType) @@ -1382,7 +1382,7 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred, // Determine the type of function we're calling (if available). const FunctionProtoType *Proto = NULL; QualType FnType = CE->getCallee()->IgnoreParens()->getType(); - if (const PointerType *FnTypePtr = FnType->getAs()) + if (const PointerType *FnTypePtr = FnType->getAsPointerType()) Proto = FnTypePtr->getPointeeType()->getAsFunctionProtoType(); VisitCallRec(CE, Pred, AI, AE, Dst, Proto, /*ParamIdx=*/0); diff --git a/clang/lib/Analysis/RegionStore.cpp b/clang/lib/Analysis/RegionStore.cpp index f956ecab7fdb..0d2467f55e0c 100644 --- a/clang/lib/Analysis/RegionStore.cpp +++ b/clang/lib/Analysis/RegionStore.cpp @@ -365,7 +365,7 @@ static bool isGenericPtr(ASTContext &Ctx, QualType Ty) { if (Ty->isVoidType()) return true; - if (const PointerType *PT = Ty->getAs()) { + if (const PointerType *PT = Ty->getAsPointerType()) { Ty = PT->getPointeeType(); continue; } @@ -680,7 +680,7 @@ SVal RegionStoreManager::EvalBinOp(const GRState *state, T = Sym->getType(getContext()); } - QualType EleTy = T->getAs()->getPointeeType(); + QualType EleTy = T->getAsPointerType()->getPointeeType(); SVal ZeroIdx = ValMgr.makeZeroArrayIndex(); ER = MRMgr.getElementRegion(EleTy, ZeroIdx, SR, getContext()); break; @@ -689,7 +689,7 @@ SVal RegionStoreManager::EvalBinOp(const GRState *state, // Get the alloca region's current cast type. const AllocaRegion *AR = cast(MR); QualType T = *(state->get(AR)); - QualType EleTy = T->getAs()->getPointeeType(); + QualType EleTy = T->getAsPointerType()->getPointeeType(); SVal ZeroIdx = ValMgr.makeZeroArrayIndex(); ER = MRMgr.getElementRegion(EleTy, ZeroIdx, AR, getContext()); break; @@ -865,7 +865,7 @@ SVal RegionStoreManager::Retrieve(const GRState *state, Loc L, QualType T) { // symbol value. if (const QualType *p = state->get(R)) { QualType T = *p; - RTy = T->getAs()->getPointeeType(); + RTy = T->getAsPointerType()->getPointeeType(); } // All other values are symbolic. @@ -937,7 +937,7 @@ SVal RegionStoreManager::RetrieveElement(const GRState* state, // If the region is already cast to another type, use that type to create the // symbol value. if (const QualType *p = state->get(R)) - Ty = (*p)->getAs()->getPointeeType(); + Ty = (*p)->getAsPointerType()->getPointeeType(); return ValMgr.getRegionValueSymbolValOrUnknown(R, Ty); } @@ -976,7 +976,7 @@ SVal RegionStoreManager::RetrieveField(const GRState* state, // symbol value. if (const QualType *p = state->get(R)) { QualType tmp = *p; - Ty = tmp->getAs()->getPointeeType(); + Ty = tmp->getAsPointerType()->getPointeeType(); } // All other values are symbolic. @@ -1009,7 +1009,7 @@ SVal RegionStoreManager::RetrieveObjCIvar(const GRState* state, // symbol value. if (const QualType *p = state->get(R)) { QualType tmp = *p; - Ty = tmp->getAs()->getPointeeType(); + Ty = tmp->getAsPointerType()->getPointeeType(); } // All other values are symbolic. @@ -1201,7 +1201,7 @@ RegionStoreManager::BindStruct(const GRState *state, const TypedRegion* R, QualType T = R->getValueType(getContext()); assert(T->isStructureType()); - const RecordType* RT = T->getAs(); + const RecordType* RT = T->getAsRecordType(); RecordDecl* RD = RT->getDecl(); if (!RD->isDefinition()) diff --git a/clang/lib/Analysis/Store.cpp b/clang/lib/Analysis/Store.cpp index 66b99a85a374..b939a0df9ca7 100644 --- a/clang/lib/Analysis/Store.cpp +++ b/clang/lib/Analysis/Store.cpp @@ -36,7 +36,7 @@ StoreManager::MakeElementRegion(const GRState *state, const MemRegion *region, } static bool IsCompleteType(ASTContext &Ctx, QualType Ty) { - if (const RecordType *RT = Ty->getAs()) { + if (const RecordType *RT = Ty->getAsRecordType()) { const RecordDecl *D = RT->getDecl(); if (!D->getDefinition(Ctx)) return false; @@ -62,7 +62,7 @@ StoreManager::NewCastRegion(const GRState *state, const MemRegion* R, // Now assume we are casting from pointer to pointer. Other cases should // already be handled. - QualType PointeeTy = CastToTy->getAs()->getPointeeType(); + QualType PointeeTy = CastToTy->getAsPointerType()->getPointeeType(); // Process region cast according to the kind of the region being cast. switch (R->getKind()) { @@ -243,7 +243,7 @@ const GRState *StoreManager::InvalidateRegion(const GRState *state, // If the region is cast to another type, use that type. if (const QualType *CastTy = getCastType(state, R)) { assert(!(*CastTy)->isObjCObjectPointerType()); - QualType NewT = (*CastTy)->getAs()->getPointeeType(); + QualType NewT = (*CastTy)->getAsPointerType()->getPointeeType(); // The only exception is if the original region had a location type as its // value type we always want to treat the region as binding to a location. diff --git a/clang/lib/CodeGen/CGBlocks.cpp b/clang/lib/CodeGen/CGBlocks.cpp index d8d1259587bc..73200fe2ca37 100644 --- a/clang/lib/CodeGen/CGBlocks.cpp +++ b/clang/lib/CodeGen/CGBlocks.cpp @@ -388,7 +388,7 @@ const llvm::Type *BlockModule::getGenericExtendedBlockLiteralType() { RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr* E) { const BlockPointerType *BPT = - E->getCallee()->getType()->getAs(); + E->getCallee()->getType()->getAsBlockPointerType(); llvm::Value *Callee = EmitScalarExpr(E->getCallee()); diff --git a/clang/lib/CodeGen/CGCXX.cpp b/clang/lib/CodeGen/CGCXX.cpp index 9031caf50526..07f387f83feb 100644 --- a/clang/lib/CodeGen/CGCXX.cpp +++ b/clang/lib/CodeGen/CGCXX.cpp @@ -179,7 +179,7 @@ CodeGenFunction::EmitCXXConstructExpr(llvm::Value *Dest, assert(Dest && "Must have a destination!"); const CXXRecordDecl *RD = - cast(E->getType()->getAs()->getDecl()); + cast(E->getType()->getAsRecordType()->getDecl()); if (RD->hasTrivialConstructor()) return; diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp index ab7b70e79301..346b6703d371 100644 --- a/clang/lib/CodeGen/CGExpr.cpp +++ b/clang/lib/CodeGen/CGExpr.cpp @@ -934,7 +934,7 @@ EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { assert(E->getBase()->getType()->isVectorType()); Base = EmitLValue(E->getBase()); } else { - const PointerType *PT = E->getBase()->getType()->getAs(); + const PointerType *PT = E->getBase()->getType()->getAsPointerType(); llvm::Value *Ptr = EmitScalarExpr(E->getBase()); Base = LValue::MakeAddr(Ptr, PT->getPointeeType().getCVRQualifiers()); } @@ -976,7 +976,7 @@ LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { if (E->isArrow()) { BaseValue = EmitScalarExpr(BaseExpr); const PointerType *PTy = - BaseExpr->getType()->getAs(); + BaseExpr->getType()->getAsPointerType(); if (PTy->getPointeeType()->isUnionType()) isUnion = true; CVRQualifiers = PTy->getPointeeType().getCVRQualifiers(); @@ -1317,7 +1317,7 @@ RValue CodeGenFunction::EmitCall(llvm::Value *Callee, QualType CalleeType, assert(CalleeType->isFunctionPointerType() && "Call must have function pointer type!"); - QualType FnType = CalleeType->getAs()->getPointeeType(); + QualType FnType = CalleeType->getAsPointerType()->getPointeeType(); QualType ResultType = FnType->getAsFunctionType()->getResultType(); CallArgList Args; diff --git a/clang/lib/CodeGen/CGExprAgg.cpp b/clang/lib/CodeGen/CGExprAgg.cpp index 58be86d2cbea..e4192d66f39a 100644 --- a/clang/lib/CodeGen/CGExprAgg.cpp +++ b/clang/lib/CodeGen/CGExprAgg.cpp @@ -253,7 +253,7 @@ void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) { } else { if (CGF.getContext().getLangOptions().NeXTRuntime) { QualType LHSTy = E->getLHS()->getType(); - if (const RecordType *FDTTy = LHSTy.getTypePtr()->getAs()) + if (const RecordType *FDTTy = LHSTy.getTypePtr()->getAsRecordType()) if (FDTTy->getDecl()->hasObjectMember()) { LValue RHS = CGF.EmitLValue(E->getRHS()); CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF, LHS.getAddress(), @@ -441,7 +441,7 @@ void AggExprEmitter::VisitInitListExpr(InitListExpr *E) { // the disadvantage is that the generated code is more difficult for // the optimizer, especially with bitfields. unsigned NumInitElements = E->getNumInits(); - RecordDecl *SD = E->getType()->getAs()->getDecl(); + RecordDecl *SD = E->getType()->getAsRecordType()->getDecl(); unsigned CurInitVal = 0; if (E->getType()->isUnionType()) { diff --git a/clang/lib/CodeGen/CGExprConstant.cpp b/clang/lib/CodeGen/CGExprConstant.cpp index dea207cc72ca..4f1f58fefdab 100644 --- a/clang/lib/CodeGen/CGExprConstant.cpp +++ b/clang/lib/CodeGen/CGExprConstant.cpp @@ -188,7 +188,7 @@ public: llvm::Constant *EmitStructInitialization(InitListExpr *ILE) { const llvm::StructType *SType = cast(ConvertType(ILE->getType())); - RecordDecl *RD = ILE->getType()->getAs()->getDecl(); + RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); std::vector Elts; // Initialize the whole structure to zero. @@ -264,7 +264,7 @@ public: #ifndef NDEBUG // Make sure that it's really an empty and not a failure of // semantic analysis. - RecordDecl *RD = ILE->getType()->getAs()->getDecl(); + RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl(); for (RecordDecl::field_iterator Field = RD->field_begin(), FieldEnd = RD->field_end(); Field != FieldEnd; ++Field) diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp index 8103506c2f47..129b4c7846ef 100644 --- a/clang/lib/CodeGen/CGExprScalar.cpp +++ b/clang/lib/CodeGen/CGExprScalar.cpp @@ -679,7 +679,7 @@ Value *ScalarExprEmitter::VisitPrePostIncDec(const UnaryOperator *E, int AmountVal = isInc ? 1 : -1; if (ValTy->isPointerType() && - ValTy->getAs()->isVariableArrayType()) { + ValTy->getAsPointerType()->isVariableArrayType()) { // The amount of the addition/subtraction needs to account for the VLA size CGF.ErrorUnsupported(E, "VLA pointer inc/dec"); } @@ -1020,13 +1020,13 @@ Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { } if (Ops.Ty->isPointerType() && - Ops.Ty->getAs()->isVariableArrayType()) { + Ops.Ty->getAsPointerType()->isVariableArrayType()) { // The amount of the addition needs to account for the VLA size CGF.ErrorUnsupported(Ops.E, "VLA pointer addition"); } Value *Ptr, *Idx; Expr *IdxExp; - const PointerType *PT = Ops.E->getLHS()->getType()->getAs(); + const PointerType *PT = Ops.E->getLHS()->getType()->getAsPointerType(); const ObjCObjectPointerType *OPT = Ops.E->getLHS()->getType()->getAsObjCObjectPointerType(); if (PT || OPT) { @@ -1034,7 +1034,7 @@ Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { Idx = Ops.RHS; IdxExp = Ops.E->getRHS(); } else { // int + pointer - PT = Ops.E->getRHS()->getType()->getAs(); + PT = Ops.E->getRHS()->getType()->getAsPointerType(); OPT = Ops.E->getRHS()->getType()->getAsObjCObjectPointerType(); assert((PT || OPT) && "Invalid add expr"); Ptr = Ops.RHS; @@ -1091,7 +1091,7 @@ Value *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { } if (Ops.E->getLHS()->getType()->isPointerType() && - Ops.E->getLHS()->getType()->getAs()->isVariableArrayType()) { + Ops.E->getLHS()->getType()->getAsPointerType()->isVariableArrayType()) { // The amount of the addition needs to account for the VLA size for // ptr-int // The amount of the division needs to account for the VLA size for diff --git a/clang/lib/CodeGen/CGObjCMac.cpp b/clang/lib/CodeGen/CGObjCMac.cpp index 02516d760844..661f75a057ca 100644 --- a/clang/lib/CodeGen/CGObjCMac.cpp +++ b/clang/lib/CodeGen/CGObjCMac.cpp @@ -3008,7 +3008,7 @@ static QualType::GCAttrTypes GetGCAttrTypeForType(ASTContext &Ctx, if (FQT->isObjCObjectPointerType()) return QualType::Strong; - if (const PointerType *PT = FQT->getAs()) + if (const PointerType *PT = FQT->getAsPointerType()) return GetGCAttrTypeForType(Ctx, PT->getPointeeType()); return QualType::GCNone; @@ -3072,7 +3072,7 @@ void CGObjCCommonMac::BuildAggrIvarLayout(const ObjCImplementationDecl *OI, if (FQT->isUnionType()) HasUnion = true; - BuildAggrIvarRecordLayout(FQT->getAs(), + BuildAggrIvarRecordLayout(FQT->getAsRecordType(), BytePos + FieldOffset, ForStrongLayout, HasUnion); continue; @@ -3097,7 +3097,7 @@ void CGObjCCommonMac::BuildAggrIvarLayout(const ObjCImplementationDecl *OI, int OldIndex = IvarsInfo.size() - 1; int OldSkIndex = SkipIvars.size() -1; - const RecordType *RT = FQT->getAs(); + const RecordType *RT = FQT->getAsRecordType(); BuildAggrIvarRecordLayout(RT, BytePos + FieldOffset, ForStrongLayout, HasUnion); diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp index 250ccce3cd04..a72f2ae71062 100644 --- a/clang/lib/CodeGen/CodeGenFunction.cpp +++ b/clang/lib/CodeGen/CodeGenFunction.cpp @@ -380,7 +380,7 @@ void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, /// getCGRecordLayout - Return record layout info. const CGRecordLayout *CodeGenFunction::getCGRecordLayout(CodeGenTypes &CGT, QualType Ty) { - const RecordType *RTy = Ty->getAs(); + const RecordType *RTy = Ty->getAsRecordType(); assert (RTy && "Unexpected type. RecordType expected here."); return CGT.getCGRecordLayout(RTy->getDecl()); @@ -490,7 +490,7 @@ llvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) return SizeEntry; } else if (const ArrayType *AT = dyn_cast(Ty)) { EmitVLASize(AT->getElementType()); - } else if (const PointerType *PT = Ty->getAs()) + } else if (const PointerType *PT = Ty->getAsPointerType()) EmitVLASize(PT->getPointeeType()); else { assert(0 && "unknown VM type!"); diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp index adc88a026bb9..d502d79d2945 100644 --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -1251,7 +1251,7 @@ GetAddrOfConstantCFString(const StringLiteral *Literal) { } QualType CFTy = getContext().getCFConstantStringType(); - RecordDecl *CFRD = CFTy->getAs()->getDecl(); + RecordDecl *CFRD = CFTy->getAsRecordType()->getDecl(); const llvm::StructType *STy = cast(getTypes().ConvertType(CFTy)); diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp index 2117e6d5b4e9..e97cbbd66c90 100644 --- a/clang/lib/CodeGen/CodeGenTypes.cpp +++ b/clang/lib/CodeGen/CodeGenTypes.cpp @@ -142,12 +142,12 @@ const llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T) { // and all of the argument types are complete. static const TagType *VerifyFuncTypeComplete(const Type* T) { const FunctionType *FT = cast(T); - if (const TagType* TT = FT->getResultType()->getAs()) + if (const TagType* TT = FT->getResultType()->getAsTagType()) if (!TT->getDecl()->isDefinition()) return TT; if (const FunctionProtoType *FPT = dyn_cast(T)) for (unsigned i = 0; i < FPT->getNumArgs(); i++) - if (const TagType* TT = FPT->getArgType(i)->getAs()) + if (const TagType* TT = FPT->getArgType(i)->getAsTagType()) if (!TT->getDecl()->isDefinition()) return TT; return 0; diff --git a/clang/lib/CodeGen/TargetABIInfo.cpp b/clang/lib/CodeGen/TargetABIInfo.cpp index 7063327d3ae3..c3f35453ba7f 100644 --- a/clang/lib/CodeGen/TargetABIInfo.cpp +++ b/clang/lib/CodeGen/TargetABIInfo.cpp @@ -68,7 +68,7 @@ static bool isEmptyField(ASTContext &Context, const FieldDecl *FD) { /// fields. Note that a structure with a flexible array member is not /// considered empty. static bool isEmptyRecord(ASTContext &Context, QualType T) { - const RecordType *RT = T->getAs(); + const RecordType *RT = T->getAsRecordType(); if (!RT) return 0; const RecordDecl *RD = RT->getDecl(); @@ -168,7 +168,7 @@ static bool typeContainsSSEVector(const RecordDecl *RD, ASTContext &Context) { Context.getTypeSize(FD->getType()) >= 128) return true; - if (const RecordType* RT = FD->getType()->getAs()) + if (const RecordType* RT = FD->getType()->getAsRecordType()) if (typeContainsSSEVector(RT->getDecl(), Context)) return true; } @@ -272,7 +272,7 @@ bool X86_32ABIInfo::shouldReturnTypeInRegister(QualType Ty, return shouldReturnTypeInRegister(AT->getElementType(), Context); // Otherwise, it must be a record type. - const RecordType *RT = Ty->getAs(); + const RecordType *RT = Ty->getAsRecordType(); if (!RT) return false; // Structure types are passed in register if all fields would be @@ -385,7 +385,7 @@ unsigned X86_32ABIInfo::getIndirectArgumentAlignment(QualType Ty, ASTContext &Context) { unsigned Align = Context.getTypeAlign(Ty); if (Align < 128) return 0; - if (const RecordType* RT = Ty->getAs()) + if (const RecordType* RT = Ty->getAsRecordType()) if (typeContainsSSEVector(RT->getDecl(), Context)) return 16; return 0; @@ -704,7 +704,7 @@ void X86_64ABIInfo::classify(QualType Ty, if (Hi == Memory) Lo = Memory; assert((Hi != SSEUp || Lo == SSE) && "Invalid SSEUp array classification."); - } else if (const RecordType *RT = Ty->getAs()) { + } else if (const RecordType *RT = Ty->getAsRecordType()) { uint64_t Size = Context.getTypeSize(Ty); // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger diff --git a/clang/lib/Frontend/PCHReader.cpp b/clang/lib/Frontend/PCHReader.cpp index fef2097773e7..8c26607b7c64 100644 --- a/clang/lib/Frontend/PCHReader.cpp +++ b/clang/lib/Frontend/PCHReader.cpp @@ -1543,7 +1543,7 @@ void PCHReader::InitializeContext(ASTContext &Ctx) { if (const TypedefType *Typedef = FileType->getAsTypedefType()) Context->setFILEDecl(Typedef->getDecl()); else { - const TagType *Tag = FileType->getAs(); + const TagType *Tag = FileType->getAsTagType(); assert(Tag && "Invalid FILE type in PCH file"); Context->setFILEDecl(Tag->getDecl()); } diff --git a/clang/lib/Frontend/RewriteBlocks.cpp b/clang/lib/Frontend/RewriteBlocks.cpp index a7b5e3d6868c..bc855fa87912 100644 --- a/clang/lib/Frontend/RewriteBlocks.cpp +++ b/clang/lib/Frontend/RewriteBlocks.cpp @@ -130,7 +130,7 @@ public: OCT == Context->getCanonicalType(Context->getObjCClassType())) return true; - if (const PointerType *PT = OCT->getAs()) { + if (const PointerType *PT = OCT->getAsPointerType()) { if (isa(PT->getPointeeType()) || PT->getPointeeType()->isObjCQualifiedIdType()) return true; @@ -684,13 +684,13 @@ std::string RewriteBlocks::SynthesizeBlockCall(CallExpr *Exp) { if (const DeclRefExpr *DRE = dyn_cast(Exp->getCallee())) { closureName = DRE->getDecl()->getNameAsCString(); - CPT = DRE->getType()->getAs(); + CPT = DRE->getType()->getAsBlockPointerType(); } else if (BlockDeclRefExpr *CDRE = dyn_cast(Exp->getCallee())) { closureName = CDRE->getDecl()->getNameAsCString(); - CPT = CDRE->getType()->getAs(); + CPT = CDRE->getType()->getAsBlockPointerType(); } else if (MemberExpr *MExpr = dyn_cast(Exp->getCallee())) { closureName = MExpr->getMemberDecl()->getNameAsCString(); - CPT = MExpr->getType()->getAs(); + CPT = MExpr->getType()->getAsBlockPointerType(); } else { assert(1 && "RewriteBlockClass: Bad type"); } @@ -813,11 +813,11 @@ void RewriteBlocks::RewriteBlockPointerFunctionArgs(FunctionDecl *FD) { bool RewriteBlocks::PointerTypeTakesAnyBlockArguments(QualType QT) { const FunctionProtoType *FTP; - const PointerType *PT = QT->getAs(); + const PointerType *PT = QT->getAsPointerType(); if (PT) { FTP = PT->getPointeeType()->getAsFunctionProtoType(); } else { - const BlockPointerType *BPT = QT->getAs(); + const BlockPointerType *BPT = QT->getAsBlockPointerType(); assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type"); FTP = BPT->getPointeeType()->getAsFunctionProtoType(); } @@ -1068,7 +1068,7 @@ void RewriteBlocks::RewriteFunctionProtoType(QualType funcType, NamedDecl *D) { } void RewriteBlocks::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) { - const PointerType *PT = funcType->getAs(); + const PointerType *PT = funcType->getAsPointerType(); if (PT && PointerTypeTakesAnyBlockArguments(funcType)) RewriteFunctionProtoType(PT->getPointeeType(), ND); } diff --git a/clang/lib/Frontend/RewriteObjC.cpp b/clang/lib/Frontend/RewriteObjC.cpp index de45e1a2bea7..1bc7451a17c2 100644 --- a/clang/lib/Frontend/RewriteObjC.cpp +++ b/clang/lib/Frontend/RewriteObjC.cpp @@ -354,7 +354,7 @@ namespace { OCT == Context->getCanonicalType(Context->getObjCClassType())) return true; - if (const PointerType *PT = OCT->getAs()) { + if (const PointerType *PT = OCT->getAsPointerType()) { if (isa(PT->getPointeeType()) || PT->getPointeeType()->isObjCQualifiedIdType()) return true; @@ -394,7 +394,7 @@ void RewriteObjC::RewriteBlocksInFunctionProtoType(QualType funcType, } void RewriteObjC::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) { - const PointerType *PT = funcType->getAs(); + const PointerType *PT = funcType->getAsPointerType(); if (PT && PointerTypeTakesAnyBlockArguments(funcType)) RewriteBlocksInFunctionProtoType(PT->getPointeeType(), ND); } @@ -864,9 +864,9 @@ void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD, // syntax (where a decaration models use). QualType retType = OMD->getResultType(); QualType PointeeTy; - if (const PointerType* PT = retType->getAs()) + if (const PointerType* PT = retType->getAsPointerType()) PointeeTy = PT->getPointeeType(); - else if (const BlockPointerType *BPT = retType->getAs()) + else if (const BlockPointerType *BPT = retType->getAsBlockPointerType()) PointeeTy = BPT->getPointeeType(); if ((FPRetType = PointeeTy->getAsFunctionType())) { ResultStr += FPRetType->getResultType().getAsString(); @@ -939,7 +939,7 @@ void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD, std::string Name = PDecl->getNameAsString(); if (isTopLevelBlockPointerType(PDecl->getType())) { // Make sure we convert "t (^)(...)" to "t (*)(...)". - const BlockPointerType *BPT = PDecl->getType()->getAs(); + const BlockPointerType *BPT = PDecl->getType()->getAsBlockPointerType(); Context->getPointerType(BPT->getPointeeType()).getAsStringInternal(Name, Context->PrintingPolicy); } else @@ -1138,7 +1138,7 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, SourceLocation OrigStart) { ObjCIvarDecl *D = IV->getDecl(); if (CurMethodDef) { - if (const PointerType *pType = IV->getBase()->getType()->getAs()) { + if (const PointerType *pType = IV->getBase()->getType()->getAsPointerType()) { ObjCInterfaceType *iFaceDecl = dyn_cast(pType->getPointeeType()); // lookup which class implements the instance variable. @@ -1184,7 +1184,7 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, // Explicit ivar refs need to have a cast inserted. // FIXME: consider sharing some of this code with the code above. - if (const PointerType *pType = IV->getBase()->getType()->getAs()) { + if (const PointerType *pType = IV->getBase()->getType()->getAsPointerType()) { ObjCInterfaceType *iFaceDecl = dyn_cast(pType->getPointeeType()); // lookup which class implements the instance variable. ObjCInterfaceDecl *clsDeclared = 0; @@ -1608,7 +1608,7 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { buf += "1) { "; ReplaceText(startLoc, lParenLoc-startBuf+1, buf.c_str(), buf.size()); sawIdTypedCatch = true; - } else if (const PointerType *pType = t->getAs()) { + } else if (const PointerType *pType = t->getAsPointerType()) { ObjCInterfaceType *cls; // Should be a pointer to a class. cls = dyn_cast(pType->getPointeeType().getTypePtr()); @@ -1824,7 +1824,7 @@ bool RewriteObjC::needToScanForQualifiers(QualType T) { if (T->isObjCQualifiedIdType()) return true; - if (const PointerType *pType = T->getAs()) { + if (const PointerType *pType = T->getAsPointerType()) { Type *pointeeType = pType->getPointeeType().getTypePtr(); if (isa(pointeeType)) return true; // we have "Class *". @@ -2485,7 +2485,7 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { : (*PI)->getType(); // Make sure we convert "t (^)(...)" to "t (*)(...)". if (isTopLevelBlockPointerType(t)) { - const BlockPointerType *BPT = t->getAs(); + const BlockPointerType *BPT = t->getAsBlockPointerType(); t = Context->getPointerType(BPT->getPointeeType()); } ArgTypes.push_back(t); @@ -3890,13 +3890,13 @@ Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp) { if (const DeclRefExpr *DRE = dyn_cast(Exp->getCallee())) { closureName = DRE->getDecl()->getNameAsCString(); - CPT = DRE->getType()->getAs(); + CPT = DRE->getType()->getAsBlockPointerType(); } else if (BlockDeclRefExpr *CDRE = dyn_cast(Exp->getCallee())) { closureName = CDRE->getDecl()->getNameAsCString(); - CPT = CDRE->getType()->getAs(); + CPT = CDRE->getType()->getAsBlockPointerType(); } else if (MemberExpr *MExpr = dyn_cast(Exp->getCallee())) { closureName = MExpr->getMemberDecl()->getNameAsCString(); - CPT = MExpr->getType()->getAs(); + CPT = MExpr->getType()->getAsBlockPointerType(); } else { assert(1 && "RewriteBlockClass: Bad type"); } @@ -3922,7 +3922,7 @@ Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp) { QualType t = *I; // Make sure we convert "t (^)(...)" to "t (*)(...)". if (isTopLevelBlockPointerType(t)) { - const BlockPointerType *BPT = t->getAs(); + const BlockPointerType *BPT = t->getAsBlockPointerType(); t = Context->getPointerType(BPT->getPointeeType()); } ArgTypes.push_back(t); @@ -4063,11 +4063,11 @@ void RewriteObjC::RewriteBlockPointerFunctionArgs(FunctionDecl *FD) { bool RewriteObjC::PointerTypeTakesAnyBlockArguments(QualType QT) { const FunctionProtoType *FTP; - const PointerType *PT = QT->getAs(); + const PointerType *PT = QT->getAsPointerType(); if (PT) { FTP = PT->getPointeeType()->getAsFunctionProtoType(); } else { - const BlockPointerType *BPT = QT->getAs(); + const BlockPointerType *BPT = QT->getAsBlockPointerType(); assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type"); FTP = BPT->getPointeeType()->getAsFunctionProtoType(); } diff --git a/clang/lib/Sema/SemaCXXScopeSpec.cpp b/clang/lib/Sema/SemaCXXScopeSpec.cpp index ef8a271fb581..a14bcd5287cd 100644 --- a/clang/lib/Sema/SemaCXXScopeSpec.cpp +++ b/clang/lib/Sema/SemaCXXScopeSpec.cpp @@ -46,7 +46,7 @@ DeclContext *Sema::computeDeclContext(const CXXScopeSpec &SS) { case NestedNameSpecifier::TypeSpec: case NestedNameSpecifier::TypeSpecWithTemplate: { - const TagType *Tag = NNS->getAsType()->getAs(); + const TagType *Tag = NNS->getAsType()->getAsTagType(); assert(Tag && "Non-tag type in nested-name-specifier"); return Tag->getDecl(); } break; @@ -169,7 +169,7 @@ bool Sema::RequireCompleteDeclContext(const CXXScopeSpec &SS) { if (TagDecl *Tag = dyn_cast(DC)) { // If we're currently defining this type, then lookup into the // type is okay: don't complain that it isn't complete yet. - const TagType *TagT = Context.getTypeDeclType(Tag)->getAs(); + const TagType *TagT = Context.getTypeDeclType(Tag)->getAsTagType(); if (TagT->isBeingDefined()) return false; diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 6256872b5e6b..4eed01872246 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -205,7 +205,7 @@ Sema::CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall) { bool HasVAListArg = Format->getFirstArg() == 0; if (!HasVAListArg) { const FunctionType *FT = - Ty->getAs()->getPointeeType()->getAsFunctionType(); + Ty->getAsBlockPointerType()->getPointeeType()->getAsFunctionType(); if (const FunctionProtoType *Proto = dyn_cast(FT)) HasVAListArg = !Proto->isVariadic(); } @@ -241,7 +241,7 @@ bool Sema::SemaBuiltinAtomicOverloaded(CallExpr *TheCall) { return Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer) << FirstArg->getType() << FirstArg->getSourceRange(); - QualType ValType = FirstArg->getType()->getAs()->getPointeeType(); + QualType ValType = FirstArg->getType()->getAsPointerType()->getPointeeType(); if (!ValType->isIntegerType() && !ValType->isPointerType() && !ValType->isBlockPointerType()) return Diag(DRE->getLocStart(), @@ -344,7 +344,7 @@ bool Sema::SemaBuiltinAtomicOverloaded(CallExpr *TheCall) { TUScope, false, DRE->getLocStart())); const FunctionProtoType *BuiltinFT = NewBuiltinDecl->getType()->getAsFunctionProtoType(); - ValType = BuiltinFT->getArgType(0)->getAs()->getPointeeType(); + ValType = BuiltinFT->getArgType(0)->getAsPointerType()->getPointeeType(); // If the first type needs to be converted (e.g. void** -> int*), do it now. if (BuiltinFT->getArgType(0) != FirstArg->getType()) { @@ -750,7 +750,7 @@ bool Sema::SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall, if (const ArrayType *AT = Context.getAsArrayType(T)) { isConstant = AT->getElementType().isConstant(Context); } - else if (const PointerType *PT = T->getAs()) { + else if (const PointerType *PT = T->getAsPointerType()) { isConstant = T.isConstant(Context) && PT->getPointeeType().isConstant(Context); } diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index d797c80353cc..92afc343f39d 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -1151,7 +1151,7 @@ bool Sema::InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner, IdResolver.AddDecl(*F); } } else if (const RecordType *InnerRecordType - = (*F)->getType()->getAs()) { + = (*F)->getType()->getAsRecordType()) { RecordDecl *InnerRecord = InnerRecordType->getDecl(); if (InnerRecord->isAnonymousStructOrUnion()) Invalid = Invalid || @@ -2814,7 +2814,7 @@ void Sema::ActOnUninitializedDecl(DeclPtrTy dcl, if ((!Var->hasExternalStorage() && !Var->isExternC(Context)) && InitType->isRecordType() && !InitType->isDependentType()) { CXXRecordDecl *RD = - cast(InitType->getAs()->getDecl()); + cast(InitType->getAsRecordType()->getDecl()); CXXConstructorDecl *Constructor = 0; if (!RequireCompleteType(Var->getLocation(), InitType, diag::err_invalid_incomplete_type_use)) @@ -4237,7 +4237,7 @@ void Sema::ActOnFields(Scope* S, FD->setInvalidDecl(); EnclosingDecl->setInvalidDecl(); continue; - } else if (const RecordType *FDTTy = FDTy->getAs()) { + } else if (const RecordType *FDTTy = FDTy->getAsRecordType()) { if (FDTTy->getDecl()->hasFlexibleArrayMember()) { // If this is a member of a union, then entire union becomes "flexible". if (Record && Record->isUnion()) { diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index ea28796ea919..09cb96b900b6 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -36,9 +36,9 @@ static const FunctionType *getFunctionType(Decl *d, bool blocksToo = true) { return 0; if (Ty->isFunctionPointerType()) - Ty = Ty->getAs()->getPointeeType(); + Ty = Ty->getAsPointerType()->getPointeeType(); else if (blocksToo && Ty->isBlockPointerType()) - Ty = Ty->getAs()->getPointeeType(); + Ty = Ty->getAsBlockPointerType()->getPointeeType(); return Ty->getAsFunctionType(); } @@ -133,11 +133,11 @@ static inline bool isNSStringType(QualType T, ASTContext &Ctx) { } static inline bool isCFStringType(QualType T, ASTContext &Ctx) { - const PointerType *PT = T->getAs(); + const PointerType *PT = T->getAsPointerType(); if (!PT) return false; - const RecordType *RT = PT->getPointeeType()->getAs(); + const RecordType *RT = PT->getPointeeType()->getAsRecordType(); if (!RT) return false; @@ -632,7 +632,7 @@ static void HandleObjCNSObject(Decl *D, const AttributeList &Attr, Sema &S) { if (TypedefDecl *TD = dyn_cast(D)) { QualType T = TD->getUnderlyingType(); if (!T->isPointerType() || - !T->getAs()->getPointeeType()->isRecordType()) { + !T->getAsPointerType()->getPointeeType()->isRecordType()) { S.Diag(TD->getLocation(), diag::err_nsobject_attribute); return; } @@ -751,7 +751,7 @@ static void HandleSentinelAttr(Decl *d, const AttributeList &Attr, Sema &S) { QualType Ty = V->getType(); if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) { const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(d) - : Ty->getAs()->getPointeeType()->getAsFunctionType(); + : Ty->getAsBlockPointerType()->getPointeeType()->getAsFunctionType(); if (!cast(FT)->isVariadic()) { int m = Ty->isFunctionPointerType() ? 0 : 1; S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m; @@ -1147,7 +1147,7 @@ static void HandleFormatArgAttr(Decl *d, const AttributeList &Attr, Sema &S) { if (not_nsstring_type && !isCFStringType(Ty, S.Context) && (!Ty->isPointerType() || - !Ty->getAs()->getPointeeType()->isCharType())) { + !Ty->getAsPointerType()->getPointeeType()->isCharType())) { // FIXME: Should highlight the actual expression that has the wrong type. S.Diag(Attr.getLoc(), diag::err_format_attribute_not) << (not_nsstring_type ? "a string type" : "an NSString") @@ -1158,7 +1158,7 @@ static void HandleFormatArgAttr(Decl *d, const AttributeList &Attr, Sema &S) { if (!isNSStringType(Ty, S.Context) && !isCFStringType(Ty, S.Context) && (!Ty->isPointerType() || - !Ty->getAs()->getPointeeType()->isCharType())) { + !Ty->getAsPointerType()->getPointeeType()->isCharType())) { // FIXME: Should highlight the actual expression that has the wrong type. S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not) << (not_nsstring_type ? "string type" : "NSString") @@ -1266,7 +1266,7 @@ static void HandleFormatAttr(Decl *d, const AttributeList &Attr, Sema &S) { return; } } else if (!Ty->isPointerType() || - !Ty->getAs()->getPointeeType()->isCharType()) { + !Ty->getAsPointerType()->getPointeeType()->isCharType()) { // FIXME: Should highlight the actual expression that has the wrong type. S.Diag(Attr.getLoc(), diag::err_format_attribute_not) << "a string type" << IdxExpr->getSourceRange(); @@ -1703,7 +1703,7 @@ static void HandleNSReturnsRetainedAttr(Decl *d, const AttributeList &Attr, return; } - if (!(S.Context.isObjCNSObjectType(RetTy) || RetTy->getAs() + if (!(S.Context.isObjCNSObjectType(RetTy) || RetTy->getAsPointerType() || RetTy->getAsObjCObjectPointerType())) { S.Diag(Attr.getLoc(), diag::warn_ns_attribute_wrong_return_type) << Attr.getName(); diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index fbc8a90fea3d..c62858ac7302 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -384,7 +384,7 @@ Sema::CheckBaseSpecifier(CXXRecordDecl *Class, return 0; // If the base class is polymorphic, the new one is, too. - RecordDecl *BaseDecl = BaseType->getAs()->getDecl(); + RecordDecl *BaseDecl = BaseType->getAsRecordType()->getDecl(); assert(BaseDecl && "Record type has no declaration"); BaseDecl = BaseDecl->getDefinition(Context); assert(BaseDecl && "Base type is not incomplete, but has no definition"); @@ -833,7 +833,7 @@ void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl, for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(), E = ClassDecl->vbases_end(); VBase != E; ++VBase) - AllBaseOrMembers.push_back(VBase->getType()->getAs()); + AllBaseOrMembers.push_back(VBase->getType()->getAsRecordType()); for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), E = ClassDecl->bases_end(); Base != E; ++Base) { @@ -841,7 +841,7 @@ void Sema::ActOnMemInitializers(DeclPtrTy ConstructorDecl, // first. if (Base->isVirtual()) continue; - AllBaseOrMembers.push_back(Base->getType()->getAs()); + AllBaseOrMembers.push_back(Base->getType()->getAsRecordType()); } for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), @@ -956,7 +956,7 @@ namespace { // First, collect the pure virtual methods for the base classes. for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(), BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base) { - if (const RecordType *RT = Base->getType()->getAs()) { + if (const RecordType *RT = Base->getType()->getAsRecordType()) { const CXXRecordDecl *BaseDecl = cast(RT->getDecl()); if (BaseDecl && BaseDecl->isAbstract()) Collect(BaseDecl, Methods); @@ -1009,9 +1009,9 @@ bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T, return RequireNonAbstractType(Loc, AT->getElementType(), DiagID, SelID, CurrentRD); - if (const PointerType *PT = T->getAs()) { + if (const PointerType *PT = T->getAsPointerType()) { // Find the innermost pointer type. - while (const PointerType *T = PT->getPointeeType()->getAs()) + while (const PointerType *T = PT->getPointeeType()->getAsPointerType()) PT = T; if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType())) @@ -1019,7 +1019,7 @@ bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T, CurrentRD); } - const RecordType *RT = T->getAs(); + const RecordType *RT = T->getAsRecordType(); if (!RT) return false; @@ -1150,7 +1150,7 @@ void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc, while (const ArrayType *AT = Context.getAsArrayType(FTy)) FTy = AT->getElementType(); - if (const RecordType *RT = FTy->getAs()) { + if (const RecordType *RT = FTy->getAsRecordType()) { CXXRecordDecl *FieldRD = cast(RT->getDecl()); if (!FieldRD->hasTrivialConstructor()) @@ -1224,7 +1224,7 @@ void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) { for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(); HasConstCopyConstructor && Base != ClassDecl->bases_end(); ++Base) { const CXXRecordDecl *BaseClassDecl - = cast(Base->getType()->getAs()->getDecl()); + = cast(Base->getType()->getAsRecordType()->getDecl()); HasConstCopyConstructor = BaseClassDecl->hasConstCopyConstructor(Context); } @@ -1239,7 +1239,7 @@ void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) { QualType FieldType = (*Field)->getType(); if (const ArrayType *Array = Context.getAsArrayType(FieldType)) FieldType = Array->getElementType(); - if (const RecordType *FieldClassType = FieldType->getAs()) { + if (const RecordType *FieldClassType = FieldType->getAsRecordType()) { const CXXRecordDecl *FieldClassDecl = cast(FieldClassType->getDecl()); HasConstCopyConstructor @@ -1304,7 +1304,7 @@ void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) { for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(); HasConstCopyAssignment && Base != ClassDecl->bases_end(); ++Base) { const CXXRecordDecl *BaseClassDecl - = cast(Base->getType()->getAs()->getDecl()); + = cast(Base->getType()->getAsRecordType()->getDecl()); HasConstCopyAssignment = BaseClassDecl->hasConstCopyAssignment(Context); } @@ -1318,7 +1318,7 @@ void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) { QualType FieldType = (*Field)->getType(); if (const ArrayType *Array = Context.getAsArrayType(FieldType)) FieldType = Array->getElementType(); - if (const RecordType *FieldClassType = FieldType->getAs()) { + if (const RecordType *FieldClassType = FieldType->getAsRecordType()) { const CXXRecordDecl *FieldClassDecl = cast(FieldClassType->getDecl()); HasConstCopyAssignment @@ -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->getAs()) + if (const ReferenceType *ConvTypeRef = ConvType->getAsReferenceType()) ConvType = ConvTypeRef->getPointeeType(); if (ConvType->isRecordType()) { ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType(); @@ -2041,7 +2041,7 @@ void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), E = ClassDecl->bases_end(); Base != E; ++Base) { CXXRecordDecl *BaseClassDecl - = cast(Base->getType()->getAs()->getDecl()); + = cast(Base->getType()->getAsRecordType()->getDecl()); if (!BaseClassDecl->hasTrivialConstructor()) { if (CXXConstructorDecl *BaseCtor = BaseClassDecl->getDefaultConstructor(Context)) @@ -2061,7 +2061,7 @@ void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, QualType FieldType = Context.getCanonicalType((*Field)->getType()); if (const ArrayType *Array = Context.getAsArrayType(FieldType)) FieldType = Array->getElementType(); - if (const RecordType *FieldClassType = FieldType->getAs()) { + if (const RecordType *FieldClassType = FieldType->getAsRecordType()) { CXXRecordDecl *FieldClassDecl = cast(FieldClassType->getDecl()); if (!FieldClassDecl->hasTrivialConstructor()) { @@ -2113,7 +2113,7 @@ void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation, for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), E = ClassDecl->bases_end(); Base != E; ++Base) { CXXRecordDecl *BaseClassDecl - = cast(Base->getType()->getAs()->getDecl()); + = cast(Base->getType()->getAsRecordType()->getDecl()); if (!BaseClassDecl->hasTrivialDestructor()) { if (CXXDestructorDecl *BaseDtor = const_cast(BaseClassDecl->getDestructor(Context))) @@ -2129,7 +2129,7 @@ void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation, QualType FieldType = Context.getCanonicalType((*Field)->getType()); if (const ArrayType *Array = Context.getAsArrayType(FieldType)) FieldType = Array->getElementType(); - if (const RecordType *FieldClassType = FieldType->getAs()) { + if (const RecordType *FieldClassType = FieldType->getAsRecordType()) { CXXRecordDecl *FieldClassDecl = cast(FieldClassType->getDecl()); if (!FieldClassDecl->hasTrivialDestructor()) { @@ -2165,7 +2165,7 @@ void Sema::DefineImplicitOverloadedAssign(SourceLocation CurrentLocation, for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), E = ClassDecl->bases_end(); Base != E; ++Base) { CXXRecordDecl *BaseClassDecl - = cast(Base->getType()->getAs()->getDecl()); + = cast(Base->getType()->getAsRecordType()->getDecl()); if (CXXMethodDecl *BaseAssignOpMethod = getAssignOperatorMethod(MethodDecl->getParamDecl(0), BaseClassDecl)) MarkDeclarationReferenced(CurrentLocation, BaseAssignOpMethod); @@ -2175,7 +2175,7 @@ void Sema::DefineImplicitOverloadedAssign(SourceLocation CurrentLocation, QualType FieldType = Context.getCanonicalType((*Field)->getType()); if (const ArrayType *Array = Context.getAsArrayType(FieldType)) FieldType = Array->getElementType(); - if (const RecordType *FieldClassType = FieldType->getAs()) { + if (const RecordType *FieldClassType = FieldType->getAsRecordType()) { CXXRecordDecl *FieldClassDecl = cast(FieldClassType->getDecl()); if (CXXMethodDecl *FieldAssignOpMethod = @@ -2251,7 +2251,7 @@ void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation, for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(); Base != ClassDecl->bases_end(); ++Base) { CXXRecordDecl *BaseClassDecl - = cast(Base->getType()->getAs()->getDecl()); + = cast(Base->getType()->getAsRecordType()->getDecl()); if (CXXConstructorDecl *BaseCopyCtor = BaseClassDecl->getCopyConstructor(Context, TypeQuals)) MarkDeclarationReferenced(CurrentLocation, BaseCopyCtor); @@ -2262,7 +2262,7 @@ void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation, QualType FieldType = Context.getCanonicalType((*Field)->getType()); if (const ArrayType *Array = Context.getAsArrayType(FieldType)) FieldType = Array->getElementType(); - if (const RecordType *FieldClassType = FieldType->getAs()) { + if (const RecordType *FieldClassType = FieldType->getAsRecordType()) { CXXRecordDecl *FieldClassDecl = cast(FieldClassType->getDecl()); if (CXXConstructorDecl *FieldCopyCtor = @@ -2286,7 +2286,7 @@ void Sema::InitializeVarWithConstructor(VarDecl *VD, void Sema::MarkDestructorReferenced(SourceLocation Loc, QualType DeclInitType) { CXXRecordDecl *ClassDecl = cast( - DeclInitType->getAs()->getDecl()); + DeclInitType->getAsRecordType()->getDecl()); if (!ClassDecl->hasTrivialDestructor()) if (CXXDestructorDecl *Destructor = const_cast(ClassDecl->getDestructor(Context))) @@ -2402,7 +2402,7 @@ Sema::PerformInitializationByConstructor(QualType ClassType, SourceLocation Loc, SourceRange Range, DeclarationName InitEntity, InitializationKind Kind) { - const RecordType *ClassRec = ClassType->getAs(); + const RecordType *ClassRec = ClassType->getAsRecordType(); assert(ClassRec && "Can only initialize a class type here"); // C++ [dcl.init]p14: @@ -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->getAs()->getPointeeType(); + QualType T1 = DeclType->getAsReferenceType()->getPointeeType(); QualType T2 = Init->getType(); // If the initializer is the address of an overloaded function, try @@ -2652,7 +2652,7 @@ Sema::CheckReferenceInit(Expr *&Init, QualType DeclType, if (!isRValRef && !SuppressUserConversions && T2->isRecordType()) { // FIXME: Look for conversions in base classes! CXXRecordDecl *T2RecordDecl - = dyn_cast(T2->getAs()->getDecl()); + = dyn_cast(T2->getAsRecordType()->getDecl()); OverloadCandidateSet CandidateSet; OverloadedFunctionDecl *Conversions @@ -3079,11 +3079,11 @@ VarDecl *Sema::BuildExceptionDeclaration(Scope *S, QualType ExDeclType, QualType BaseType = ExDeclType; int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference unsigned DK = diag::err_catch_incomplete; - if (const PointerType *Ptr = BaseType->getAs()) { + if (const PointerType *Ptr = BaseType->getAsPointerType()) { BaseType = Ptr->getPointeeType(); Mode = 1; DK = diag::err_catch_incomplete_ptr; - } else if(const ReferenceType *Ref = BaseType->getAs()) { + } else if(const ReferenceType *Ref = BaseType->getAsReferenceType()) { // 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 ff5ead0694ae..130455804280 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -133,8 +133,8 @@ void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, QualType Ty = V->getType(); if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) { const FunctionType *FT = Ty->isFunctionPointerType() - ? Ty->getAs()->getPointeeType()->getAsFunctionType() - : Ty->getAs()->getPointeeType()->getAsFunctionType(); + ? Ty->getAsPointerType()->getPointeeType()->getAsFunctionType() + : Ty->getAsBlockPointerType()->getPointeeType()->getAsFunctionType(); if (const FunctionProtoType *Proto = dyn_cast(FT)) { unsigned NumArgsInProto = Proto->getNumArgs(); unsigned k; @@ -756,7 +756,7 @@ Sema::BuildAnonymousStructUnionMemberReference(SourceLocation Loc, // whether its a pointer and whether it adds any qualifiers to the // anonymous struct/union fields we're looking into. QualType ObjectType = BaseObjectExpr->getType(); - if (const PointerType *ObjectPtr = ObjectType->getAs()) { + if (const PointerType *ObjectPtr = ObjectType->getAsPointerType()) { BaseObjectIsPointer = true; ObjectType = ObjectPtr->getPointeeType(); } @@ -1073,7 +1073,7 @@ Sema::BuildDeclarationNameExpr(SourceLocation Loc, NamedDecl *D, Ctx = FD->getDeclContext(); MemberType = FD->getType(); - if (const ReferenceType *RefType = MemberType->getAs()) + if (const ReferenceType *RefType = MemberType->getAsReferenceType()) MemberType = RefType->getPointeeType(); else if (!FD->isMutable()) { unsigned combinedQualifiers @@ -1835,11 +1835,11 @@ Sema::ActOnArraySubscriptExpr(Scope *S, ExprArg Base, SourceLocation LLoc, BaseExpr = LHSExp; IndexExpr = RHSExp; ResultType = Context.DependentTy; - } else if (const PointerType *PTy = LHSTy->getAs()) { + } else if (const PointerType *PTy = LHSTy->getAsPointerType()) { BaseExpr = LHSExp; IndexExpr = RHSExp; ResultType = PTy->getPointeeType(); - } else if (const PointerType *PTy = RHSTy->getAs()) { + } else if (const PointerType *PTy = RHSTy->getAsPointerType()) { // Handle the uncommon case of "123[Ptr]". BaseExpr = RHSExp; IndexExpr = LHSExp; @@ -1874,7 +1874,7 @@ Sema::ActOnArraySubscriptExpr(Scope *S, ExprArg Base, SourceLocation LLoc, BaseExpr = LHSExp; IndexExpr = RHSExp; - ResultType = LHSTy->getAs()->getPointeeType(); + ResultType = LHSTy->getAsPointerType()->getPointeeType(); } else if (RHSTy->isArrayType()) { // Same as previous, except for 123[f().a] case Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << @@ -1884,7 +1884,7 @@ Sema::ActOnArraySubscriptExpr(Scope *S, ExprArg Base, SourceLocation LLoc, BaseExpr = RHSExp; IndexExpr = LHSExp; - ResultType = RHSTy->getAs()->getPointeeType(); + ResultType = RHSTy->getAsPointerType()->getPointeeType(); } else { return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value) << LHSExp->getSourceRange() << RHSExp->getSourceRange()); @@ -2098,7 +2098,7 @@ Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc, OpLoc, DeclarationName(&Member), MemberLoc)); - else if (const PointerType *PT = BaseType->getAs()) + else if (const PointerType *PT = BaseType->getAsPointerType()) BaseType = PT->getPointeeType(); else if (BaseType->isObjCObjectPointerType()) ; @@ -2119,7 +2119,7 @@ Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc, // In Obj-C++, however, the above expression is valid, since it could be // accessing the 'f' property if T is an Obj-C interface. The extra check // allows this, while still reporting an error if T is a struct pointer. - const PointerType *PT = BaseType->getAs(); + const PointerType *PT = BaseType->getAsPointerType(); if (!PT || (getLangOptions().ObjC1 && !PT->getPointeeType()->isRecordType())) @@ -2133,7 +2133,7 @@ Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc, // Handle field access to simple records. This also handles access to fields // of the ObjC 'id' struct. - if (const RecordType *RTy = BaseType->getAs()) { + if (const RecordType *RTy = BaseType->getAsRecordType()) { RecordDecl *RDecl = RTy->getDecl(); if (RequireCompleteType(OpLoc, BaseType, diag::err_typecheck_incomplete_tag, @@ -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->getAs()) + if (const ReferenceType *Ref = MemberType->getAsReferenceType()) MemberType = Ref->getPointeeType(); else { unsigned combinedQualifiers = @@ -2500,7 +2500,7 @@ Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc, if (BaseType == Context.OverloadTy || BaseType->isFunctionType() || (BaseType->isPointerType() && - BaseType->getAs()->isFunctionType())) { + BaseType->getAsPointerType()->isFunctionType())) { SourceLocation Loc = PP.getLocForEndOfToken(BaseExpr->getLocEnd()); Diag(Loc, diag::note_member_reference_needs_call) << CodeModificationHint::CreateInsertion(Loc, "()"); @@ -2794,13 +2794,13 @@ Sema::ActOnCallExpr(Scope *S, ExprArg fn, SourceLocation LParenLoc, if (!Fn->getType()->isBlockPointerType()) { // C99 6.5.2.2p1 - "The expression that denotes the called function shall // have type pointer to function". - const PointerType *PT = Fn->getType()->getAs(); + const PointerType *PT = Fn->getType()->getAsPointerType(); if (PT == 0) return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) << Fn->getType() << Fn->getSourceRange()); FuncT = PT->getPointeeType()->getAsFunctionType(); } else { // This is a block call. - FuncT = Fn->getType()->getAs()->getPointeeType()-> + FuncT = Fn->getType()->getAsBlockPointerType()->getPointeeType()-> getAsFunctionType(); } if (FuncT == 0) @@ -2937,7 +2937,7 @@ bool Sema::CheckCastTypes(SourceRange TyR, QualType castType, Expr *&castExpr) { << castType << castExpr->getSourceRange(); } else if (castType->isUnionType()) { // GCC cast to union extension - RecordDecl *RD = castType->getAs()->getDecl(); + RecordDecl *RD = castType->getAsRecordType()->getDecl(); RecordDecl::field_iterator Field, FieldEnd; for (Field = RD->field_begin(), FieldEnd = RD->field_end(); Field != FieldEnd; ++Field) { @@ -3078,8 +3078,8 @@ QualType Sema::CheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, // If both operands are the same structure or union type, the result is that // type. - if (const RecordType *LHSRT = LHSTy->getAs()) { // C99 6.5.15p3 - if (const RecordType *RHSRT = RHSTy->getAs()) + if (const RecordType *LHSRT = LHSTy->getAsRecordType()) { // C99 6.5.15p3 + if (const RecordType *RHSRT = RHSTy->getAsRecordType()) if (LHSRT->getDecl() == RHSRT->getDecl()) // "If both the operands have structure or union type, the result has // that type." This implies that CV qualifiers are dropped. @@ -3131,8 +3131,8 @@ QualType Sema::CheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, return LHSTy; } // The block pointer types aren't identical, continue checking. - QualType lhptee = LHSTy->getAs()->getPointeeType(); - QualType rhptee = RHSTy->getAs()->getPointeeType(); + QualType lhptee = LHSTy->getAsBlockPointerType()->getPointeeType(); + QualType rhptee = RHSTy->getAsBlockPointerType()->getPointeeType(); if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(), rhptee.getUnqualifiedType())) { @@ -3206,8 +3206,8 @@ QualType Sema::CheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, // Check constraints for C object pointers types (C99 6.5.15p3,6). if (LHSTy->isPointerType() && RHSTy->isPointerType()) { // get the "pointed to" types - QualType lhptee = LHSTy->getAs()->getPointeeType(); - QualType rhptee = RHSTy->getAs()->getPointeeType(); + QualType lhptee = LHSTy->getAsPointerType()->getPointeeType(); + QualType rhptee = RHSTy->getAsPointerType()->getPointeeType(); // ignore qualifiers on void (C99 6.5.15p3, clause 6) if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) { @@ -3313,8 +3313,8 @@ Sema::CheckPointerTypesForAssignment(QualType lhsType, QualType rhsType) { QualType lhptee, rhptee; // get the "pointed to" type (ignoring qualifiers at the top level) - lhptee = lhsType->getAs()->getPointeeType(); - rhptee = rhsType->getAs()->getPointeeType(); + lhptee = lhsType->getAsPointerType()->getPointeeType(); + rhptee = rhsType->getAsPointerType()->getPointeeType(); return CheckPointeeTypesForAssignment(lhptee, rhptee); } @@ -3396,8 +3396,8 @@ Sema::CheckBlockPointerTypesForAssignment(QualType lhsType, QualType lhptee, rhptee; // get the "pointed to" type (ignoring qualifiers at the top level) - lhptee = lhsType->getAs()->getPointeeType(); - rhptee = rhsType->getAs()->getPointeeType(); + lhptee = lhsType->getAsBlockPointerType()->getPointeeType(); + rhptee = rhsType->getAsBlockPointerType()->getPointeeType(); // make sure we operate on the canonical type lhptee = Context.getCanonicalType(lhptee); @@ -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->getAs()) { + if (const ReferenceType *lhsTypeRef = lhsType->getAsReferenceType()) { if (Context.typesAreCompatible(lhsTypeRef->getPointeeType(), rhsType)) return Compatible; return Incompatible; @@ -3496,12 +3496,12 @@ Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) { if (isa(rhsType)) { QualType rhptee = rhsType->getAsObjCObjectPointerType()->getPointeeType(); - QualType lhptee = lhsType->getAs()->getPointeeType(); + QualType lhptee = lhsType->getAsPointerType()->getPointeeType(); return CheckPointeeTypesForAssignment(lhptee, rhptee); } - if (rhsType->getAs()) { - if (lhsType->getAs()->getPointeeType()->isVoidType()) + if (rhsType->getAsBlockPointerType()) { + if (lhsType->getAsPointerType()->getPointeeType()->isVoidType()) return Compatible; // Treat block pointers as objects. @@ -3522,7 +3522,7 @@ Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) { if (rhsType->isBlockPointerType()) return CheckBlockPointerTypesForAssignment(lhsType, rhsType); - if (const PointerType *RHSPT = rhsType->getAs()) { + if (const PointerType *RHSPT = rhsType->getAsPointerType()) { if (RHSPT->getPointeeType()->isVoidType()) return Compatible; } @@ -3535,7 +3535,7 @@ Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) { if (isa(rhsType)) { QualType lhptee = lhsType->getAsObjCObjectPointerType()->getPointeeType(); - QualType rhptee = rhsType->getAs()->getPointeeType(); + QualType rhptee = rhsType->getAsPointerType()->getPointeeType(); return CheckPointeeTypesForAssignment(lhptee, rhptee); } if (rhsType->isObjCObjectPointerType()) { @@ -3545,7 +3545,7 @@ Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) { QualType rhptee = rhsType->getAsObjCObjectPointerType()->getPointeeType(); return CheckPointeeTypesForAssignment(lhptee, rhptee); } - if (const PointerType *RHSPT = rhsType->getAs()) { + if (const PointerType *RHSPT = rhsType->getAsPointerType()) { if (RHSPT->getPointeeType()->isVoidType()) return Compatible; } @@ -3566,7 +3566,7 @@ Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) { return CheckPointerTypesForAssignment(lhsType, rhsType); if (isa(lhsType) && - rhsType->getAs()->getPointeeType()->isVoidType()) + rhsType->getAsPointerType()->getPointeeType()->isVoidType()) return Compatible; return Incompatible; } @@ -3580,11 +3580,11 @@ Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) { if (isa(lhsType)) { QualType rhptee = lhsType->getAsObjCObjectPointerType()->getPointeeType(); - QualType lhptee = rhsType->getAs()->getPointeeType(); + QualType lhptee = rhsType->getAsPointerType()->getPointeeType(); return CheckPointeeTypesForAssignment(lhptee, rhptee); } if (isa(lhsType) && - rhsType->getAs()->getPointeeType()->isVoidType()) + rhsType->getAsPointerType()->getPointeeType()->isVoidType()) return Compatible; return Incompatible; } @@ -3636,7 +3636,7 @@ Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, Expr *&rExpr) { // 1) void pointer // 2) null pointer constant if (FromType->isPointerType()) - if (FromType->getAs()->getPointeeType()->isVoidType()) { + if (FromType->getAsPointerType()->getPointeeType()->isVoidType()) { ImpCastExprToType(rExpr, it->getType()); InitField = *it; break; @@ -3973,7 +3973,7 @@ QualType Sema::CheckSubtractionOperands(Expr *&lex, Expr *&rex, } // Handle pointer-pointer subtractions. - if (const PointerType *RHSPTy = rex->getType()->getAs()) { + if (const PointerType *RHSPTy = rex->getType()->getAsPointerType()) { QualType rpointee = RHSPTy->getPointeeType(); // RHS must be a completely-type object type. @@ -4168,9 +4168,9 @@ QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc, // errors (when -pedantic-errors is enabled). if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2 QualType LCanPointeeTy = - Context.getCanonicalType(lType->getAs()->getPointeeType()); + Context.getCanonicalType(lType->getAsPointerType()->getPointeeType()); QualType RCanPointeeTy = - Context.getCanonicalType(rType->getAs()->getPointeeType()); + Context.getCanonicalType(rType->getAsPointerType()->getPointeeType()); if (isRelational) { if (lType->isFunctionPointerType() || rType->isFunctionPointerType()) { @@ -4240,8 +4240,8 @@ QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc, } // Handle block pointer types. if (!isRelational && lType->isBlockPointerType() && rType->isBlockPointerType()) { - QualType lpointee = lType->getAs()->getPointeeType(); - QualType rpointee = rType->getAs()->getPointeeType(); + QualType lpointee = lType->getAsBlockPointerType()->getPointeeType(); + QualType rpointee = rType->getAsBlockPointerType()->getPointeeType(); if (!LHSIsNull && !RHSIsNull && !Context.typesAreCompatible(lpointee, rpointee)) { @@ -4256,9 +4256,9 @@ QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc, && ((lType->isBlockPointerType() && rType->isPointerType()) || (lType->isPointerType() && rType->isBlockPointerType()))) { if (!LHSIsNull && !RHSIsNull) { - if (!((rType->isPointerType() && rType->getAs() + if (!((rType->isPointerType() && rType->getAsPointerType() ->getPointeeType()->isVoidType()) - || (lType->isPointerType() && lType->getAs() + || (lType->isPointerType() && lType->getAsPointerType() ->getPointeeType()->isVoidType()))) Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) << lType << rType << lex->getSourceRange() << rex->getSourceRange(); @@ -4269,8 +4269,8 @@ QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc, if ((lType->isObjCObjectPointerType() || rType->isObjCObjectPointerType())) { if (lType->isPointerType() || rType->isPointerType()) { - const PointerType *LPT = lType->getAs(); - const PointerType *RPT = rType->getAs(); + const PointerType *LPT = lType->getAsPointerType(); + const PointerType *RPT = rType->getAsPointerType(); bool LPtrToVoid = LPT ? Context.getCanonicalType(LPT->getPointeeType())->isVoidType() : false; bool RPtrToVoid = RPT ? @@ -4798,7 +4798,7 @@ QualType Sema::CheckIndirectionOperand(Expr *Op, SourceLocation OpLoc) { // incomplete type or void. It would be possible to warn about dereferencing // a void pointer, but it's completely well-defined, and such a warning is // unlikely to catch any mistakes. - if (const PointerType *PT = Ty->getAs()) + if (const PointerType *PT = Ty->getAsPointerType()) return PT->getPointeeType(); if (const ObjCObjectPointerType *OPT = Ty->getAsObjCObjectPointerType()) @@ -5256,7 +5256,7 @@ Sema::OwningExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, continue; } - const RecordType *RC = Res->getType()->getAs(); + const RecordType *RC = Res->getType()->getAsRecordType(); if (!RC) { Res->Destroy(Context); return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type) diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp index 8b7baff972c8..144dc5095f8d 100644 --- a/clang/lib/Sema/SemaExprCXX.cpp +++ b/clang/lib/Sema/SemaExprCXX.cpp @@ -83,7 +83,7 @@ Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, Expr *E = static_cast(TyOrExpr); if (E && !E->isTypeDependent() && E->isLvalue(Context) == Expr::LV_Valid) { QualType T = E->getType(); - if (const RecordType *RecordT = T->getAs()) { + if (const RecordType *RecordT = T->getAsRecordType()) { CXXRecordDecl *RecordD = cast(RecordT->getDecl()); if (RecordD->isPolymorphic()) isUnevaluatedOperand = false; @@ -136,7 +136,7 @@ bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E) { // to an incomplete type other than (cv) void the program is ill-formed. QualType Ty = E->getType(); int isPointer = 0; - if (const PointerType* Ptr = Ty->getAs()) { + if (const PointerType* Ptr = Ty->getAsPointerType()) { Ty = Ptr->getPointeeType(); isPointer = 1; } @@ -211,7 +211,7 @@ Sema::ActOnCXXTypeConstructExpr(SourceRange TypeRange, TypeTy *TypeRep, RParenLoc)); } - if (const RecordType *RT = Ty->getAs()) { + if (const RecordType *RT = Ty->getAsRecordType()) { CXXRecordDecl *Record = cast(RT->getDecl()); // FIXME: We should always create a CXXTemporaryObjectExpr here unless @@ -414,7 +414,7 @@ Sema::BuildCXXNew(SourceLocation StartLoc, bool UseGlobal, if (AllocType->isDependentType()) { // Skip all the checks. } - else if ((RT = AllocType->getAs()) && + else if ((RT = AllocType->getAsRecordType()) && !AllocType->isAggregateType()) { Constructor = PerformInitializationByConstructor( AllocType, ConsArgs, NumConsArgs, @@ -516,7 +516,7 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, IsArray ? OO_Array_New : OO_New); if (AllocType->isRecordType() && !UseGlobal) { CXXRecordDecl *Record - = cast(AllocType->getAs()->getDecl()); + = cast(AllocType->getAsRecordType()->getDecl()); // FIXME: We fail to find inherited overloads. if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0], AllocArgs.size(), Record, /*AllowMissing=*/true, @@ -708,7 +708,7 @@ Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, return ExprError(Diag(StartLoc, diag::err_delete_operand) << Type << Ex->getSourceRange()); - QualType Pointee = Type->getAs()->getPointeeType(); + QualType Pointee = Type->getAsPointerType()->getPointeeType(); if (Pointee->isFunctionType() || Pointee->isVoidType()) return ExprError(Diag(StartLoc, diag::err_delete_operand) << Type << Ex->getSourceRange()); @@ -757,7 +757,7 @@ Sema::ActOnCXXConditionDeclarationExpr(Scope *S, SourceLocation StartLoc, } else if (Ty->isArrayType()) { // ...or an array. Diag(StartLoc, diag::err_invalid_use_of_array_type) << SourceRange(StartLoc, EqualLoc); - } else if (const RecordType *RT = Ty->getAs()) { + } else if (const RecordType *RT = Ty->getAsRecordType()) { RecordDecl *RD = RT->getDecl(); // The type-specifier-seq shall not declare a new class... if (RD->isDefinition() && @@ -812,7 +812,7 @@ Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { // string literal can be converted to an rvalue of type "pointer // to wchar_t" (C++ 4.2p2). if (StringLiteral *StrLit = dyn_cast(From)) - if (const PointerType *ToPtrType = ToType->getAs()) + if (const PointerType *ToPtrType = ToType->getAsPointerType()) if (const BuiltinType *ToPointeeType = ToPtrType->getPointeeType()->getAsBuiltinType()) { // This conversion is considered only when there is an @@ -1051,7 +1051,7 @@ QualType Sema::CheckPointerToMemberOperands( // be of type "pointer to member of T" (where T is a completely-defined // class type) [...] QualType RType = rex->getType(); - const MemberPointerType *MemPtr = RType->getAs(); + const MemberPointerType *MemPtr = RType->getAsMemberPointerType(); if (!MemPtr) { Diag(Loc, diag::err_bad_memptr_rhs) << OpSpelling << RType << rex->getSourceRange(); @@ -1066,7 +1066,7 @@ QualType Sema::CheckPointerToMemberOperands( // such a class] QualType LType = lex->getType(); if (isIndirect) { - if (const PointerType *Ptr = LType->getAs()) + if (const PointerType *Ptr = LType->getAsPointerType()) LType = Ptr->getPointeeType().getNonReferenceType(); else { Diag(Loc, diag::err_bad_memptr_lhs) @@ -1163,8 +1163,8 @@ static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, // the same or one is a base class of the other: QualType FTy = From->getType(); QualType TTy = To->getType(); - const RecordType *FRec = FTy->getAs(); - const RecordType *TRec = TTy->getAs(); + const RecordType *FRec = FTy->getAsRecordType(); + const RecordType *TRec = TTy->getAsRecordType(); bool FDerivedFromT = FRec && TRec && Self.IsDerivedFrom(FTy, TTy); if (FRec && TRec && (FRec == TRec || FDerivedFromT || Self.IsDerivedFrom(TTy, FTy))) { @@ -1418,8 +1418,8 @@ QualType Sema::CXXCheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, // containing class, and second-level cv-ness. // cv-ness is not a union, but must match one of the two operands. (Which, // frankly, is stupid.) - const MemberPointerType *LMemPtr = LTy->getAs(); - const MemberPointerType *RMemPtr = RTy->getAs(); + const MemberPointerType *LMemPtr = LTy->getAsMemberPointerType(); + const MemberPointerType *RMemPtr = RTy->getAsMemberPointerType(); if (LMemPtr && RHS->isNullPointerConstant(Context)) { ImpCastExprToType(RHS, LTy); return LTy; @@ -1515,8 +1515,8 @@ QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2) { llvm::SmallVector QualifierUnion; QualType Composite1 = T1, Composite2 = T2; const PointerType *Ptr1, *Ptr2; - while ((Ptr1 = Composite1->getAs()) && - (Ptr2 = Composite2->getAs())) { + while ((Ptr1 = Composite1->getAsPointerType()) && + (Ptr2 = Composite2->getAsPointerType())) { Composite1 = Ptr1->getPointeeType(); Composite2 = Ptr2->getPointeeType(); QualifierUnion.push_back( @@ -1562,7 +1562,7 @@ QualType Sema::FindCompositePointerType(Expr *&E1, Expr *&E2) { } Sema::OwningExprResult Sema::MaybeBindToTemporary(Expr *E) { - const RecordType *RT = E->getType()->getAs(); + const RecordType *RT = E->getType()->getAsRecordType(); if (!RT) return Owned(E); diff --git a/clang/lib/Sema/SemaExprObjC.cpp b/clang/lib/Sema/SemaExprObjC.cpp index c20956827b82..1131a9f0d846 100644 --- a/clang/lib/Sema/SemaExprObjC.cpp +++ b/clang/lib/Sema/SemaExprObjC.cpp @@ -859,7 +859,7 @@ bool Sema::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs, if (!lhs->isPointerType()) return false; - QualType ltype = lhs->getAs()->getPointeeType(); + QualType ltype = lhs->getAsPointerType()->getPointeeType(); if (const ObjCQualifiedInterfaceType *lhsQI = ltype->getAsObjCQualifiedInterfaceType()) { ObjCObjectPointerType::qual_iterator LHSProtoI = lhsQI->qual_begin(); diff --git a/clang/lib/Sema/SemaInherit.cpp b/clang/lib/Sema/SemaInherit.cpp index be235e927158..2f914f14a81f 100644 --- a/clang/lib/Sema/SemaInherit.cpp +++ b/clang/lib/Sema/SemaInherit.cpp @@ -114,7 +114,7 @@ bool Sema::IsDerivedFrom(QualType Derived, QualType Base, BasePaths &Paths) { return false; Paths.setOrigin(Derived); - return LookupInBases(cast(Derived->getAs()->getDecl()), + return LookupInBases(cast(Derived->getAsRecordType()->getDecl()), MemberLookupCriteria(Base), Paths); } @@ -156,7 +156,7 @@ bool Sema::LookupInBases(CXXRecordDecl *Class, if (Paths.isDetectingVirtual() && Paths.DetectedVirtual == 0) { // If this is the first virtual we find, remember it. If it turns out // there is no base path here, we'll reset it later. - Paths.DetectedVirtual = BaseType->getAs(); + Paths.DetectedVirtual = BaseType->getAsRecordType(); SetVirtual = true; } } else @@ -175,7 +175,7 @@ bool Sema::LookupInBases(CXXRecordDecl *Class, } CXXRecordDecl *BaseRecord - = cast(BaseSpec->getType()->getAs()->getDecl()); + = cast(BaseSpec->getType()->getAsRecordType()->getDecl()); // Either look at the base class type or look into the base class // type to see if we've found a member that meets the search diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp index d92f37fb2560..52099a3d904f 100644 --- a/clang/lib/Sema/SemaInit.cpp +++ b/clang/lib/Sema/SemaInit.cpp @@ -162,7 +162,7 @@ bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType, if ((DeclTypeC.getUnqualifiedType() == InitTypeC.getUnqualifiedType()) || IsDerivedFrom(InitTypeC, DeclTypeC)) { const CXXRecordDecl *RD = - cast(DeclType->getAs()->getDecl()); + cast(DeclType->getAsRecordType()->getDecl()); // No need to make a CXXConstructExpr if both the ctor and dtor are // trivial. @@ -341,7 +341,7 @@ void InitListChecker::FillInValueInitializations(InitListExpr *ILE) { if (ILE->getSyntacticForm()) Loc = ILE->getSyntacticForm()->getSourceRange().getBegin(); - if (const RecordType *RType = ILE->getType()->getAs()) { + if (const RecordType *RType = ILE->getType()->getAsRecordType()) { unsigned Init = 0, NumInits = ILE->getNumInits(); for (RecordDecl::field_iterator Field = RType->getDecl()->field_begin(), @@ -447,7 +447,7 @@ int InitListChecker::numArrayElements(QualType DeclType) { } int InitListChecker::numStructUnionElements(QualType DeclType) { - RecordDecl *structDecl = DeclType->getAs()->getDecl(); + RecordDecl *structDecl = DeclType->getAsRecordType()->getDecl(); int InitializableMembers = 0; for (RecordDecl::field_iterator Field = structDecl->field_begin(), @@ -584,7 +584,7 @@ void InitListChecker::CheckListElementTypes(InitListExpr *IList, CheckVectorType(IList, DeclType, Index, StructuredList, StructuredIndex); } else if (DeclType->isAggregateType()) { if (DeclType->isRecordType()) { - RecordDecl *RD = DeclType->getAs()->getDecl(); + RecordDecl *RD = DeclType->getAsRecordType()->getDecl(); CheckStructUnionTypes(IList, DeclType, RD->field_begin(), SubobjectIsDesignatorContext, Index, StructuredList, StructuredIndex, @@ -939,7 +939,7 @@ void InitListChecker::CheckStructUnionTypes(InitListExpr *IList, InitListExpr *StructuredList, unsigned &StructuredIndex, bool TopLevelObject) { - RecordDecl* structDecl = DeclType->getAs()->getDecl(); + RecordDecl* structDecl = DeclType->getAsRecordType()->getDecl(); // If the record is invalid, some of it's members are invalid. To avoid // confusion, we forgo checking the intializer for the entire record. @@ -950,7 +950,7 @@ void InitListChecker::CheckStructUnionTypes(InitListExpr *IList, if (DeclType->isUnionType() && IList->getNumInits() == 0) { // Value-initialize the first named member of the union. - RecordDecl *RD = DeclType->getAs()->getDecl(); + RecordDecl *RD = DeclType->getAsRecordType()->getDecl(); for (RecordDecl::field_iterator FieldEnd = RD->field_end(); Field != FieldEnd; ++Field) { if (Field->getDeclName()) { @@ -965,7 +965,7 @@ void InitListChecker::CheckStructUnionTypes(InitListExpr *IList, // anything except look at designated initializers; That's okay, // because an error should get printed out elsewhere. It might be // worthwhile to skip over the rest of the initializer, though. - RecordDecl *RD = DeclType->getAs()->getDecl(); + RecordDecl *RD = DeclType->getAsRecordType()->getDecl(); RecordDecl::field_iterator FieldEnd = RD->field_end(); bool InitializedSomething = false; while (Index < IList->getNumInits()) { @@ -1204,7 +1204,7 @@ InitListChecker::CheckDesignatedInitializer(InitListExpr *IList, // then the current object (defined below) shall have // structure or union type and the identifier shall be the // name of a member of that type. - const RecordType *RT = CurrentObjectType->getAs(); + const RecordType *RT = CurrentObjectType->getAsRecordType(); if (!RT) { SourceLocation Loc = D->getDotLoc(); if (Loc.isInvalid()) @@ -1564,7 +1564,7 @@ InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, } } else if (const VectorType *VType = CurrentObjectType->getAsVectorType()) NumElements = VType->getNumElements(); - else if (const RecordType *RType = CurrentObjectType->getAs()) { + else if (const RecordType *RType = CurrentObjectType->getAsRecordType()) { RecordDecl *RDecl = RType->getDecl(); if (RDecl->isUnion()) NumElements = 1; @@ -1758,7 +1758,7 @@ bool Sema::CheckValueInitialization(QualType Type, SourceLocation Loc) { if (const ArrayType *AT = Context.getAsArrayType(Type)) return CheckValueInitialization(AT->getElementType(), Loc); - if (const RecordType *RT = Type->getAs()) { + if (const RecordType *RT = Type->getAsRecordType()) { if (CXXRecordDecl *ClassDecl = dyn_cast(RT->getDecl())) { // -- if T is a class type (clause 9) with a user-declared // constructor (12.1), then the default constructor for T is diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp index 1ca341262036..c88321e1a355 100644 --- a/clang/lib/Sema/SemaLookup.cpp +++ b/clang/lib/Sema/SemaLookup.cpp @@ -1387,7 +1387,7 @@ addAssociatedClassesAndNamespaces(CXXRecordDecl *Class, for (CXXRecordDecl::base_class_iterator Base = Class->bases_begin(), BaseEnd = Class->bases_end(); Base != BaseEnd; ++Base) { - const RecordType *BaseType = Base->getType()->getAs(); + const RecordType *BaseType = Base->getType()->getAsRecordType(); CXXRecordDecl *BaseDecl = cast(BaseType->getDecl()); if (AssociatedClasses.insert(BaseDecl)) { // Find the associated namespace for this base class. @@ -1435,7 +1435,7 @@ addAssociatedClassesAndNamespaces(QualType T, // We handle this by unwrapping pointer and array types immediately, // to avoid unnecessary recursion. while (true) { - if (const PointerType *Ptr = T->getAs()) + if (const PointerType *Ptr = T->getAsPointerType()) T = Ptr->getPointeeType(); else if (const ArrayType *Ptr = Context.getAsArrayType(T)) T = Ptr->getElementType(); @@ -1453,7 +1453,7 @@ addAssociatedClassesAndNamespaces(QualType T, // member, if any; and its direct and indirect base // classes. Its associated namespaces are the namespaces in // which its associated classes are defined. - if (const RecordType *ClassType = T->getAs()) + if (const RecordType *ClassType = T->getAsRecordType()) if (CXXRecordDecl *ClassDecl = dyn_cast(ClassType->getDecl())) { addAssociatedClassesAndNamespaces(ClassDecl, Context, @@ -1519,7 +1519,7 @@ addAssociatedClassesAndNamespaces(QualType T, // associated namespaces and classes are those associated // with the member type together with those associated with // X. - if (const MemberPointerType *MemberPtr = T->getAs()) { + if (const MemberPointerType *MemberPtr = T->getAsMemberPointerType()) { // Handle the type that the pointer to member points to. addAssociatedClassesAndNamespaces(MemberPtr->getPointeeType(), Context, @@ -1527,7 +1527,7 @@ addAssociatedClassesAndNamespaces(QualType T, GlobalScope); // Handle the class type into which this points. - if (const RecordType *Class = MemberPtr->getClass()->getAs()) + if (const RecordType *Class = MemberPtr->getClass()->getAsRecordType()) addAssociatedClassesAndNamespaces(cast(Class->getDecl()), Context, AssociatedNamespaces, AssociatedClasses, diff --git a/clang/lib/Sema/SemaNamedCast.cpp b/clang/lib/Sema/SemaNamedCast.cpp index 0dedd3a4bc73..daf6800ea0c0 100644 --- a/clang/lib/Sema/SemaNamedCast.cpp +++ b/clang/lib/Sema/SemaNamedCast.cpp @@ -118,7 +118,7 @@ CheckConstCast(Sema &Self, Expr *&SrcExpr, QualType DestType, DestType = Self.Context.getCanonicalType(DestType); QualType SrcType = SrcExpr->getType(); if (const LValueReferenceType *DestTypeTmp = - DestType->getAs()) { + DestType->getAsLValueReferenceType()) { if (SrcExpr->isLvalue(Self.Context) != Expr::LV_Valid) { // Cannot cast non-lvalue to lvalue reference type. Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_rvalue) @@ -220,7 +220,7 @@ CheckReinterpretCast(Sema &Self, Expr *&SrcExpr, QualType DestType, DestType = Self.Context.getCanonicalType(DestType); QualType SrcType = SrcExpr->getType(); if (const LValueReferenceType *DestTypeTmp = - DestType->getAs()) { + DestType->getAsLValueReferenceType()) { if (SrcExpr->isLvalue(Self.Context) != Expr::LV_Valid) { // Cannot cast non-lvalue to reference type. Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_rvalue) @@ -235,7 +235,7 @@ CheckReinterpretCast(Sema &Self, Expr *&SrcExpr, QualType DestType, DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType()); SrcType = Self.Context.getPointerType(SrcType); } else if (const RValueReferenceType *DestTypeTmp = - DestType->getAs()) { + DestType->getAsRValueReferenceType()) { // Both the reference conversion and the rvalue rules apply. Self.DefaultFunctionArrayConversion(SrcExpr); SrcType = SrcExpr->getType(); @@ -253,8 +253,8 @@ CheckReinterpretCast(Sema &Self, Expr *&SrcExpr, QualType DestType, // Canonicalize source for comparison. SrcType = Self.Context.getCanonicalType(SrcType); - const MemberPointerType *DestMemPtr = DestType->getAs(), - *SrcMemPtr = SrcType->getAs(); + const MemberPointerType *DestMemPtr = DestType->getAsMemberPointerType(), + *SrcMemPtr = SrcType->getAsMemberPointerType(); if (DestMemPtr && SrcMemPtr) { // C++ 5.2.10p9: An rvalue of type "pointer to member of X of type T1" // can be explicitly converted to an rvalue of type "pointer to member @@ -529,10 +529,10 @@ CheckStaticCast(Sema &Self, Expr *&SrcExpr, QualType DestType, // Reverse pointer conversion to void*. C++ 4.10.p2 specifies conversion to // void*. C++ 5.2.9p10 specifies additional restrictions, which really is // just the usual constness stuff. - if (const PointerType *SrcPointer = SrcType->getAs()) { + if (const PointerType *SrcPointer = SrcType->getAsPointerType()) { QualType SrcPointee = SrcPointer->getPointeeType(); if (SrcPointee->isVoidType()) { - if (const PointerType *DestPointer = DestType->getAs()) { + if (const PointerType *DestPointer = DestType->getAsPointerType()) { QualType DestPointee = DestPointer->getPointeeType(); if (DestPointee->isIncompleteOrObjectType()) { // This is definitely the intended conversion, but it might fail due @@ -563,7 +563,7 @@ TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, QualType DestType, { // N2844 5.2.9p3: An lvalue of type "cv1 T1" can be cast to type "rvalue // reference to cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1". - const RValueReferenceType *R = DestType->getAs(); + const RValueReferenceType *R = DestType->getAsRValueReferenceType(); if (!R) return TSC_NotApplicable; @@ -604,7 +604,7 @@ TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType, return TSC_NotApplicable; } - const ReferenceType *DestReference = DestType->getAs(); + const ReferenceType *DestReference = DestType->getAsReferenceType(); if (!DestReference) { return TSC_NotApplicable; } @@ -627,12 +627,12 @@ TryStaticPointerDowncast(Sema &Self, QualType SrcType, QualType DestType, // In addition, DR54 clarifies that the base must be accessible in the // current context. - const PointerType *SrcPointer = SrcType->getAs(); + const PointerType *SrcPointer = SrcType->getAsPointerType(); if (!SrcPointer) { return TSC_NotApplicable; } - const PointerType *DestPointer = DestType->getAs(); + const PointerType *DestPointer = DestType->getAsPointerType(); if (!DestPointer) { return TSC_NotApplicable; } @@ -738,10 +738,10 @@ TryStaticCastResult TryStaticMemberPointerUpcast(Sema &Self, QualType SrcType, QualType DestType, const SourceRange &OpRange) { - const MemberPointerType *SrcMemPtr = SrcType->getAs(); + const MemberPointerType *SrcMemPtr = SrcType->getAsMemberPointerType(); if (!SrcMemPtr) return TSC_NotApplicable; - const MemberPointerType *DestMemPtr = DestType->getAs(); + const MemberPointerType *DestMemPtr = DestType->getAsMemberPointerType(); if (!DestMemPtr) return TSC_NotApplicable; @@ -828,8 +828,8 @@ CheckDynamicCast(Sema &Self, Expr *&SrcExpr, QualType DestType, // or "pointer to cv void". QualType DestPointee; - const PointerType *DestPointer = DestType->getAs(); - const ReferenceType *DestReference = DestType->getAs(); + const PointerType *DestPointer = DestType->getAsPointerType(); + const ReferenceType *DestReference = DestType->getAsReferenceType(); if (DestPointer) { DestPointee = DestPointer->getPointeeType(); } else if (DestReference) { @@ -840,7 +840,7 @@ CheckDynamicCast(Sema &Self, Expr *&SrcExpr, QualType DestType, return; } - const RecordType *DestRecord = DestPointee->getAs(); + const RecordType *DestRecord = DestPointee->getAsRecordType(); if (DestPointee->isVoidType()) { assert(DestPointer && "Reference to void is not possible"); } else if (DestRecord) { @@ -863,7 +863,7 @@ CheckDynamicCast(Sema &Self, Expr *&SrcExpr, QualType DestType, QualType SrcType = Self.Context.getCanonicalType(OrigSrcType); QualType SrcPointee; if (DestPointer) { - if (const PointerType *SrcPointer = SrcType->getAs()) { + if (const PointerType *SrcPointer = SrcType->getAsPointerType()) { SrcPointee = SrcPointer->getPointeeType(); } else { Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ptr) @@ -880,7 +880,7 @@ CheckDynamicCast(Sema &Self, Expr *&SrcExpr, QualType DestType, SrcPointee = SrcType; } - const RecordType *SrcRecord = SrcPointee->getAs(); + const RecordType *SrcRecord = SrcPointee->getAsRecordType(); if (SrcRecord) { if (Self.RequireCompleteType(OpRange.getBegin(), SrcPointee, diag::err_bad_dynamic_cast_incomplete, diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index 0a161578f8e6..d0d61c6ed1a0 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -173,7 +173,7 @@ isPointerConversionToVoidPointer(ASTContext& Context) const FromType = Context.getArrayDecayedType(FromType); if (Second == ICK_Pointer_Conversion) - if (const PointerType* ToPtrType = ToType->getAs()) + if (const PointerType* ToPtrType = ToType->getAsPointerType()) return ToPtrType->getPointeeType()->isVoidType(); return false; @@ -915,7 +915,7 @@ bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType, // Blocks: Block pointers can be converted to void*. if (FromType->isBlockPointerType() && ToType->isPointerType() && - ToType->getAs()->getPointeeType()->isVoidType()) { + ToType->getAsPointerType()->getPointeeType()->isVoidType()) { ConvertedType = ToType; return true; } @@ -933,7 +933,7 @@ bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType, return true; } - const PointerType* ToTypePtr = ToType->getAs(); + const PointerType* ToTypePtr = ToType->getAsPointerType(); if (!ToTypePtr) return false; @@ -944,7 +944,7 @@ bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType, } // Beyond this point, both types need to be pointers. - const PointerType *FromTypePtr = FromType->getAs(); + const PointerType *FromTypePtr = FromType->getAsPointerType(); if (!FromTypePtr) return false; @@ -1042,17 +1042,17 @@ bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType, } // Beyond this point, both types need to be C pointers or block pointers. QualType ToPointeeType; - if (const PointerType *ToCPtr = ToType->getAs()) + if (const PointerType *ToCPtr = ToType->getAsPointerType()) ToPointeeType = ToCPtr->getPointeeType(); - else if (const BlockPointerType *ToBlockPtr = ToType->getAs()) + else if (const BlockPointerType *ToBlockPtr = ToType->getAsBlockPointerType()) ToPointeeType = ToBlockPtr->getPointeeType(); else return false; QualType FromPointeeType; - if (const PointerType *FromCPtr = FromType->getAs()) + if (const PointerType *FromCPtr = FromType->getAsPointerType()) FromPointeeType = FromCPtr->getPointeeType(); - else if (const BlockPointerType *FromBlockPtr = FromType->getAs()) + else if (const BlockPointerType *FromBlockPtr = FromType->getAsBlockPointerType()) FromPointeeType = FromBlockPtr->getPointeeType(); else return false; @@ -1142,8 +1142,8 @@ bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType, bool Sema::CheckPointerConversion(Expr *From, QualType ToType) { QualType FromType = From->getType(); - if (const PointerType *FromPtrType = FromType->getAs()) - if (const PointerType *ToPtrType = ToType->getAs()) { + if (const PointerType *FromPtrType = FromType->getAsPointerType()) + if (const PointerType *ToPtrType = ToType->getAsPointerType()) { QualType FromPointeeType = FromPtrType->getPointeeType(), ToPointeeType = ToPtrType->getPointeeType(); @@ -1178,7 +1178,7 @@ bool Sema::CheckPointerConversion(Expr *From, QualType ToType) { bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType, QualType &ConvertedType) { - const MemberPointerType *ToTypePtr = ToType->getAs(); + const MemberPointerType *ToTypePtr = ToType->getAsMemberPointerType(); if (!ToTypePtr) return false; @@ -1189,7 +1189,7 @@ bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType, } // Otherwise, both types have to be member pointers. - const MemberPointerType *FromTypePtr = FromType->getAs(); + const MemberPointerType *FromTypePtr = FromType->getAsMemberPointerType(); if (!FromTypePtr) return false; @@ -1216,11 +1216,11 @@ bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType, /// otherwise. bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType) { QualType FromType = From->getType(); - const MemberPointerType *FromPtrType = FromType->getAs(); + const MemberPointerType *FromPtrType = FromType->getAsMemberPointerType(); if (!FromPtrType) return false; - const MemberPointerType *ToPtrType = ToType->getAs(); + const MemberPointerType *ToPtrType = ToType->getAsMemberPointerType(); assert(ToPtrType && "No member pointer cast has a target type " "that is not a member pointer."); @@ -1340,7 +1340,7 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType, bool AllowExplicit, bool ForceRValue) { OverloadCandidateSet CandidateSet; - if (const RecordType *ToRecordType = ToType->getAs()) { + if (const RecordType *ToRecordType = ToType->getAsRecordType()) { if (CXXRecordDecl *ToRecordDecl = dyn_cast(ToRecordType->getDecl())) { // C++ [over.match.ctor]p1: @@ -1369,7 +1369,7 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType, if (!AllowConversionFunctions) { // Don't allow any conversion functions to enter the overload set. } else if (const RecordType *FromRecordType - = From->getType()->getAs()) { + = From->getType()->getAsRecordType()) { if (CXXRecordDecl *FromRecordDecl = dyn_cast(FromRecordType->getDecl())) { // Add all of the conversion functions as candidates. @@ -1404,7 +1404,7 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType, User.ConversionFunction = Constructor; User.After.setAsIdentityConversion(); User.After.FromTypePtr - = ThisType->getAs()->getPointeeType().getAsOpaquePtr(); + = ThisType->getAsPointerType()->getPointeeType().getAsOpaquePtr(); User.After.ToTypePtr = ToType.getAsOpaquePtr(); return true; } else if (CXXConversionDecl *Conversion @@ -1579,9 +1579,9 @@ Sema::CompareStandardConversionSequences(const StandardConversionSequence& SCS1, FromType2 = Context.getArrayDecayedType(FromType2); QualType FromPointee1 - = FromType1->getAs()->getPointeeType().getUnqualifiedType(); + = FromType1->getAsPointerType()->getPointeeType().getUnqualifiedType(); QualType FromPointee2 - = FromType2->getAs()->getPointeeType().getUnqualifiedType(); + = FromType2->getAsPointerType()->getPointeeType().getUnqualifiedType(); if (IsDerivedFrom(FromPointee2, FromPointee1)) return ImplicitConversionSequence::Better; @@ -1771,13 +1771,13 @@ Sema::CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1, FromType1->isPointerType() && FromType2->isPointerType() && ToType1->isPointerType() && ToType2->isPointerType()) { QualType FromPointee1 - = FromType1->getAs()->getPointeeType().getUnqualifiedType(); + = FromType1->getAsPointerType()->getPointeeType().getUnqualifiedType(); QualType ToPointee1 - = ToType1->getAs()->getPointeeType().getUnqualifiedType(); + = ToType1->getAsPointerType()->getPointeeType().getUnqualifiedType(); QualType FromPointee2 - = FromType2->getAs()->getPointeeType().getUnqualifiedType(); + = FromType2->getAsPointerType()->getPointeeType().getUnqualifiedType(); QualType ToPointee2 - = ToType2->getAs()->getPointeeType().getUnqualifiedType(); + = ToType2->getAsPointerType()->getPointeeType().getUnqualifiedType(); const ObjCInterfaceType* FromIface1 = FromPointee1->getAsObjCInterfaceType(); const ObjCInterfaceType* FromIface2 = FromPointee2->getAsObjCInterfaceType(); @@ -1943,7 +1943,7 @@ Sema::TryObjectArgumentInitialization(Expr *From, CXXMethodDecl *Method) { // We need to have an object of class type. QualType FromType = From->getType(); - if (const PointerType *PT = FromType->getAs()) + if (const PointerType *PT = FromType->getAsPointerType()) FromType = PT->getPointeeType(); assert(FromType->isRecordType()); @@ -1991,9 +1991,9 @@ bool Sema::PerformObjectArgumentInitialization(Expr *&From, CXXMethodDecl *Method) { QualType FromRecordType, DestType; QualType ImplicitParamRecordType = - Method->getThisType(Context)->getAs()->getPointeeType(); + Method->getThisType(Context)->getAsPointerType()->getPointeeType(); - if (const PointerType *PT = From->getType()->getAs()) { + if (const PointerType *PT = From->getType()->getAsPointerType()) { FromRecordType = PT->getPointeeType(); DestType = Method->getThisType(Context); } else { @@ -2500,7 +2500,7 @@ void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op, // (13.3.1.1.1); otherwise, the set of member candidates is // empty. // FIXME: Lookup in base classes, too! - if (const RecordType *T1Rec = T1->getAs()) { + if (const RecordType *T1Rec = T1->getAsRecordType()) { DeclContext::lookup_const_iterator Oper, OperEnd; for (llvm::tie(Oper, OperEnd) = T1Rec->getDecl()->lookup(OpName); Oper != OperEnd; ++Oper) @@ -2634,7 +2634,7 @@ BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty) { if (!PointerTypes.insert(Ty)) return false; - if (const PointerType *PointerTy = Ty->getAs()) { + if (const PointerType *PointerTy = Ty->getAsPointerType()) { QualType PointeeTy = PointerTy->getPointeeType(); // FIXME: Optimize this so that we don't keep trying to add the same types. @@ -2668,7 +2668,7 @@ BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants( if (!MemberPointerTypes.insert(Ty)) return false; - if (const MemberPointerType *PointerTy = Ty->getAs()) { + if (const MemberPointerType *PointerTy = Ty->getAsMemberPointerType()) { QualType PointeeTy = PointerTy->getPointeeType(); const Type *ClassTy = PointerTy->getClass(); // FIXME: Optimize this so that we don't keep trying to add the same types. @@ -2704,13 +2704,13 @@ 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->getAs()) + if (const ReferenceType *RefTy = Ty->getAsReferenceType()) Ty = RefTy->getPointeeType(); // We don't care about qualifiers on the type. Ty = Ty.getUnqualifiedType(); - if (const PointerType *PointerTy = Ty->getAs()) { + if (const PointerType *PointerTy = Ty->getAsPointerType()) { QualType PointeeTy = PointerTy->getPointeeType(); // Insert our type, and its more-qualified variants, into the set @@ -2728,7 +2728,7 @@ BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty, // If this is a pointer to a class type, add pointers to its bases // (with the same level of cv-qualification as the original // derived class, of course). - if (const RecordType *PointeeRec = PointeeTy->getAs()) { + if (const RecordType *PointeeRec = PointeeTy->getAsRecordType()) { CXXRecordDecl *ClassDecl = cast(PointeeRec->getDecl()); for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(); Base != ClassDecl->bases_end(); ++Base) { @@ -2747,7 +2747,7 @@ BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty, } else if (Ty->isEnumeralType()) { EnumerationTypes.insert(Ty); } else if (AllowUserConversions) { - if (const RecordType *TyRec = Ty->getAs()) { + if (const RecordType *TyRec = Ty->getAsRecordType()) { CXXRecordDecl *ClassDecl = cast(TyRec->getDecl()); // FIXME: Visit conversion functions in the base classes, too. OverloadedFunctionDecl *Conversions @@ -2898,7 +2898,7 @@ Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, for (BuiltinCandidateTypeSet::iterator Ptr = CandidateTypes.pointer_begin(); Ptr != CandidateTypes.pointer_end(); ++Ptr) { // Skip pointer types that aren't pointers to object types. - if (!(*Ptr)->getAs()->getPointeeType()->isObjectType()) + if (!(*Ptr)->getAsPointerType()->getPointeeType()->isObjectType()) continue; QualType ParamTypes[2] = { @@ -2936,7 +2936,7 @@ Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, for (BuiltinCandidateTypeSet::iterator Ptr = CandidateTypes.pointer_begin(); Ptr != CandidateTypes.pointer_end(); ++Ptr) { QualType ParamTy = *Ptr; - QualType PointeeTy = ParamTy->getAs()->getPointeeType(); + QualType PointeeTy = ParamTy->getAsPointerType()->getPointeeType(); AddBuiltinCandidate(Context.getLValueReferenceType(PointeeTy), &ParamTy, Args, 1, CandidateSet); } @@ -3336,7 +3336,7 @@ Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, for (BuiltinCandidateTypeSet::iterator Ptr = CandidateTypes.pointer_begin(); Ptr != CandidateTypes.pointer_end(); ++Ptr) { QualType ParamTypes[2] = { *Ptr, Context.getPointerDiffType() }; - QualType PointeeType = (*Ptr)->getAs()->getPointeeType(); + QualType PointeeType = (*Ptr)->getAsPointerType()->getPointeeType(); QualType ResultTy = Context.getLValueReferenceType(PointeeType); // T& operator[](T*, ptrdiff_t) @@ -3616,15 +3616,15 @@ Sema::PrintOverloadCandidates(OverloadCandidateSet& CandidateSet, bool isRValueReference = false; bool isPointer = false; if (const LValueReferenceType *FnTypeRef = - FnType->getAs()) { + FnType->getAsLValueReferenceType()) { FnType = FnTypeRef->getPointeeType(); isLValueReference = true; } else if (const RValueReferenceType *FnTypeRef = - FnType->getAs()) { + FnType->getAsRValueReferenceType()) { FnType = FnTypeRef->getPointeeType(); isRValueReference = true; } - if (const PointerType *FnTypePtr = FnType->getAs()) { + if (const PointerType *FnTypePtr = FnType->getAsPointerType()) { FnType = FnTypePtr->getPointeeType(); isPointer = true; } @@ -3673,12 +3673,12 @@ Sema::ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType, bool Complain) { QualType FunctionType = ToType; bool IsMember = false; - if (const PointerType *ToTypePtr = ToType->getAs()) + if (const PointerType *ToTypePtr = ToType->getAsPointerType()) FunctionType = ToTypePtr->getPointeeType(); - else if (const ReferenceType *ToTypeRef = ToType->getAs()) + else if (const ReferenceType *ToTypeRef = ToType->getAsReferenceType()) FunctionType = ToTypeRef->getPointeeType(); else if (const MemberPointerType *MemTypePtr = - ToType->getAs()) { + ToType->getAsMemberPointerType()) { FunctionType = MemTypePtr->getPointeeType(); IsMember = true; } @@ -4367,7 +4367,7 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation *CommaLocs, SourceLocation RParenLoc) { assert(Object->getType()->isRecordType() && "Requires object type argument"); - const RecordType *Record = Object->getType()->getAs(); + const RecordType *Record = Object->getType()->getAsRecordType(); // C++ [over.call.object]p1: // If the primary-expression E in the function call syntax @@ -4414,7 +4414,7 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Object, // Strip the reference type (if any) and then the pointer type (if // any) to get down to what might be a function type. QualType ConvType = Conv->getConversionType().getNonReferenceType(); - if (const PointerType *ConvPtrType = ConvType->getAs()) + if (const PointerType *ConvPtrType = ConvType->getAsPointerType()) ConvType = ConvPtrType->getPointeeType(); if (const FunctionProtoType *Proto = ConvType->getAsFunctionProtoType()) @@ -4579,7 +4579,7 @@ Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, // FIXME: look in base classes. DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Arrow); OverloadCandidateSet CandidateSet; - const RecordType *BaseRecord = Base->getType()->getAs(); + const RecordType *BaseRecord = Base->getType()->getAsRecordType(); DeclContext::lookup_const_iterator Oper, OperEnd; for (llvm::tie(Oper, OperEnd) diff --git a/clang/lib/Sema/SemaStmt.cpp b/clang/lib/Sema/SemaStmt.cpp index 0a7ed462f81e..bd2b0aef3d36 100644 --- a/clang/lib/Sema/SemaStmt.cpp +++ b/clang/lib/Sema/SemaStmt.cpp @@ -1204,7 +1204,7 @@ Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, ExprArg expr,Scope *CurScope) { QualType ThrowType = ThrowExpr->getType(); // Make sure the expression type is an ObjC pointer or "void *". if (!ThrowType->isObjCObjectPointerType()) { - const PointerType *PT = ThrowType->getAs(); + const PointerType *PT = ThrowType->getAsPointerType(); if (!PT || !PT->getPointeeType()->isVoidType()) return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object) << ThrowExpr->getType() << ThrowExpr->getSourceRange()); @@ -1221,7 +1221,7 @@ Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, ExprArg SynchExpr, // Make sure the expression type is an ObjC pointer or "void *". Expr *SyncExpr = static_cast(SynchExpr.get()); if (!SyncExpr->getType()->isObjCObjectPointerType()) { - const PointerType *PT = SyncExpr->getType()->getAs(); + const PointerType *PT = SyncExpr->getType()->getAsPointerType(); if (!PT || !PT->getPointeeType()->isVoidType()) return StmtError(Diag(AtLoc, diag::error_objc_synchronized_expects_object) << SyncExpr->getType() << SyncExpr->getSourceRange()); diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index 9ee4f3fcabd1..568d68c9a7e8 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -225,8 +225,8 @@ Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) { if (T->isIntegralType() || T->isEnumeralType() || // -- pointer to object or pointer to function, (T->isPointerType() && - (T->getAs()->getPointeeType()->isObjectType() || - T->getAs()->getPointeeType()->isFunctionType())) || + (T->getAsPointerType()->getPointeeType()->isObjectType() || + T->getAsPointerType()->getPointeeType()->isFunctionType())) || // -- reference to object or reference to function, T->isReferenceType() || // -- pointer to member. @@ -1329,7 +1329,7 @@ bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param, const TagType *Tag = 0; if (const EnumType *EnumT = Arg->getAsEnumType()) Tag = EnumT; - else if (const RecordType *RecordT = Arg->getAs()) + else if (const RecordType *RecordT = Arg->getAsRecordType()) Tag = RecordT; if (Tag && Tag->getDecl()->getDeclContext()->isFunctionOrMethod()) return Diag(ArgLoc, diag::err_template_arg_local_type) @@ -1648,13 +1648,13 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, // function is selected from the set (13.4). // In C++0x, any std::nullptr_t value can be converted. (ParamType->isPointerType() && - ParamType->getAs()->getPointeeType()->isFunctionType()) || + ParamType->getAsPointerType()->getPointeeType()->isFunctionType()) || // -- For a non-type template-parameter of type reference to // function, no conversions apply. If the template-argument // represents a set of overloaded functions, the matching // function is selected from the set (13.4). (ParamType->isReferenceType() && - ParamType->getAs()->getPointeeType()->isFunctionType()) || + ParamType->getAsReferenceType()->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 @@ -1662,7 +1662,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, // the set (13.4). // Again, C++0x allows a std::nullptr_t value. (ParamType->isMemberPointerType() && - ParamType->getAs()->getPointeeType() + ParamType->getAsMemberPointerType()->getPointeeType() ->isFunctionType())) { if (Context.hasSameUnqualifiedType(ArgType, ParamType.getNonReferenceType())) { @@ -1721,7 +1721,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, // object, qualification conversions (4.4) and the // array-to-pointer conversion (4.2) are applied. // C++0x also allows a value of std::nullptr_t. - assert(ParamType->getAs()->getPointeeType()->isObjectType() && + assert(ParamType->getAsPointerType()->getPointeeType()->isObjectType() && "Only object pointers allowed here"); if (ArgType->isNullPtrType()) { @@ -1755,7 +1755,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, return false; } - if (const ReferenceType *ParamRefType = ParamType->getAs()) { + if (const ReferenceType *ParamRefType = ParamType->getAsReferenceType()) { // -- 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 5c4f6e796929..f6f9d105d95d 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -397,7 +397,7 @@ DeduceTemplateArguments(ASTContext &Context, // T * case Type::Pointer: { - const PointerType *PointerArg = Arg->getAs(); + const PointerType *PointerArg = Arg->getAsPointerType(); if (!PointerArg) return Sema::TDK_NonDeducedMismatch; @@ -410,7 +410,7 @@ DeduceTemplateArguments(ASTContext &Context, // T & case Type::LValueReference: { - const LValueReferenceType *ReferenceArg = Arg->getAs(); + const LValueReferenceType *ReferenceArg = Arg->getAsLValueReferenceType(); if (!ReferenceArg) return Sema::TDK_NonDeducedMismatch; @@ -422,7 +422,7 @@ DeduceTemplateArguments(ASTContext &Context, // T && [C++0x] case Type::RValueReference: { - const RValueReferenceType *ReferenceArg = Arg->getAs(); + const RValueReferenceType *ReferenceArg = Arg->getAsRValueReferenceType(); if (!ReferenceArg) return Sema::TDK_NonDeducedMismatch; @@ -615,7 +615,7 @@ DeduceTemplateArguments(ASTContext &Context, Base != BaseEnd; ++Base) { assert(Base->getType()->isRecordType() && "Base class that isn't a record?"); - ToVisit.push_back(Base->getType()->getAs()); + ToVisit.push_back(Base->getType()->getAsRecordType()); } } @@ -1282,7 +1282,7 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, // are ignored for type deduction. if (CanonParamType.getCVRQualifiers()) ParamType = CanonParamType.getUnqualifiedType(); - if (const ReferenceType *ParamRefType = ParamType->getAs()) { + if (const ReferenceType *ParamRefType = ParamType->getAsReferenceType()) { // [...] If P is a reference type, the type referred to by P is used // for type deduction. ParamType = ParamRefType->getPointeeType(); @@ -1320,7 +1320,7 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, if (isSimpleTemplateIdType(ParamType) || (isa(ParamType) && isSimpleTemplateIdType( - ParamType->getAs()->getPointeeType()))) + ParamType->getAsPointerType()->getPointeeType()))) TDF |= TDF_DerivedClass; if (TemplateDeductionResult Result diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 6f28e272c409..8195aba967a2 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -300,8 +300,8 @@ QualType Sema::ConvertDeclSpecToType(const DeclSpec &DS, if (TypeQuals & QualType::Restrict) { if (Result->isPointerType() || Result->isReferenceType()) { QualType EltTy = Result->isPointerType() ? - Result->getAs()->getPointeeType() : - Result->getAs()->getPointeeType(); + Result->getAsPointerType()->getPointeeType() : + Result->getAsReferenceType()->getPointeeType(); // If we have a pointer or reference, the pointee must have an object // incomplete type. @@ -414,7 +414,7 @@ QualType Sema::BuildPointerType(QualType T, unsigned Quals, QualType Sema::BuildReferenceType(QualType T, bool LValueRef, unsigned Quals, SourceLocation Loc, DeclarationName Entity) { if (LValueRef) { - if (const RValueReferenceType *R = T->getAs()) { + if (const RValueReferenceType *R = T->getAsRValueReferenceType()) { // C++0x [dcl.typedef]p9: If a typedef TD names a type that is a // reference to a type T, and attempt to create the type "lvalue // reference to cv TD" creates the type "lvalue reference to T". @@ -524,7 +524,7 @@ QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, return QualType(); } - if (const RecordType *EltTy = T->getAs()) { + if (const RecordType *EltTy = T->getAsRecordType()) { // If the element type is a struct or union that contains a variadic // array, accept it as a GNU extension: C99 6.7.2.1p2. if (EltTy->getDecl()->hasFlexibleArrayMember()) @@ -1185,10 +1185,10 @@ bool Sema::CheckSpecifiedExceptionType(QualType T, const SourceRange &Range) { // an incomplete type a pointer or reference to an incomplete type, other // than (cv) void*. int kind; - if (const PointerType* IT = T->getAs()) { + if (const PointerType* IT = T->getAsPointerType()) { T = IT->getPointeeType(); kind = 1; - } else if (const ReferenceType* IT = T->getAs()) { + } else if (const ReferenceType* IT = T->getAsReferenceType()) { T = IT->getPointeeType(); kind = 2; } else @@ -1205,9 +1205,9 @@ bool Sema::CheckSpecifiedExceptionType(QualType T, const SourceRange &Range) { /// to member to a function with an exception specification. This means that /// it is invalid to add another level of indirection. bool Sema::CheckDistantExceptionSpec(QualType T) { - if (const PointerType *PT = T->getAs()) + if (const PointerType *PT = T->getAsPointerType()) T = PT->getPointeeType(); - else if (const MemberPointerType *PT = T->getAs()) + else if (const MemberPointerType *PT = T->getAsMemberPointerType()) T = PT->getPointeeType(); else return false; @@ -1285,9 +1285,9 @@ 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->getAs()) + if (const ReferenceType *RefTy = CanonicalSubT->getAsReferenceType()) CanonicalSubT = RefTy->getPointeeType(); - if (const PointerType *PtrTy = CanonicalSubT->getAs()) { + if (const PointerType *PtrTy = CanonicalSubT->getAsPointerType()) { CanonicalSubT = PtrTy->getPointeeType(); SubIsPointer = true; } @@ -1305,10 +1305,10 @@ 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->getAs()) + if (const ReferenceType *RefTy = CanonicalSuperT->getAsReferenceType()) CanonicalSuperT = RefTy->getPointeeType(); if (SubIsPointer) { - if (const PointerType *PtrTy = CanonicalSuperT->getAs()) + if (const PointerType *PtrTy = CanonicalSuperT->getAsPointerType()) CanonicalSuperT = PtrTy->getPointeeType(); else { continue; @@ -1384,16 +1384,16 @@ QualType Sema::ObjCGetTypeForMethodDefinition(DeclPtrTy D) { /// be called in a loop that successively "unwraps" pointer and /// pointer-to-member types to compare them at each level. bool Sema::UnwrapSimilarPointerTypes(QualType& T1, QualType& T2) { - const PointerType *T1PtrType = T1->getAs(), - *T2PtrType = T2->getAs(); + const PointerType *T1PtrType = T1->getAsPointerType(), + *T2PtrType = T2->getAsPointerType(); if (T1PtrType && T2PtrType) { T1 = T1PtrType->getPointeeType(); T2 = T2PtrType->getPointeeType(); return true; } - const MemberPointerType *T1MPType = T1->getAs(), - *T2MPType = T2->getAs(); + const MemberPointerType *T1MPType = T1->getAsMemberPointerType(), + *T2MPType = T2->getAsMemberPointerType(); if (T1MPType && T2MPType && Context.getCanonicalType(T1MPType->getClass()) == Context.getCanonicalType(T2MPType->getClass())) { @@ -1567,7 +1567,7 @@ bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, unsigned diag, // If we have a class template specialization or a class member of a // class template specialization, try to instantiate it. - if (const RecordType *Record = T->getAs()) { + if (const RecordType *Record = T->getAsRecordType()) { if (ClassTemplateSpecializationDecl *ClassTemplateSpec = dyn_cast(Record->getDecl())) { if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared) { @@ -1603,7 +1603,7 @@ bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, unsigned diag, // If the type was a forward declaration of a class/struct/union // type, produce const TagType *Tag = 0; - if (const RecordType *Record = T->getAs()) + if (const RecordType *Record = T->getAsRecordType()) Tag = Record; else if (const EnumType *Enum = T->getAsEnumType()) Tag = Enum; -- GitLab