From 2a1ba94f245fec30aef438cdb3e7c24a4fc9f348 Mon Sep 17 00:00:00 2001 From: Eugene Zelenko Date: Mon, 9 Apr 2018 22:14:10 +0000 Subject: [PATCH] [AST] Fix some Clang-tidy modernize-use-auto warnings; other minor fixes (NFC). llvm-svn: 329630 --- clang/include/clang/AST/ASTStructuralEquivalence.h | 9 +- clang/lib/AST/ASTStructuralEquivalence.cpp | 212 +++++++++------------ clang/lib/AST/DeclBase.cpp | 152 +++++++-------- clang/lib/AST/DeclObjC.cpp | 134 ++++++------- 4 files changed, 233 insertions(+), 274 deletions(-) diff --git a/clang/include/clang/AST/ASTStructuralEquivalence.h b/clang/include/clang/AST/ASTStructuralEquivalence.h index 23674c6..d21be99 100644 --- a/clang/include/clang/AST/ASTStructuralEquivalence.h +++ b/clang/include/clang/AST/ASTStructuralEquivalence.h @@ -1,4 +1,4 @@ -//===--- ASTStructuralEquivalence.h - ---------------------------*- C++ -*-===// +//===- ASTStructuralEquivalence.h -------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -19,6 +19,7 @@ #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/Optional.h" #include +#include namespace clang { @@ -57,7 +58,7 @@ struct StructuralEquivalenceContext { bool Complain; /// \c true if the last diagnostic came from ToCtx. - bool LastDiagFromC2; + bool LastDiagFromC2 = false; StructuralEquivalenceContext( ASTContext &FromCtx, ASTContext &ToCtx, @@ -66,8 +67,7 @@ struct StructuralEquivalenceContext { bool ErrorOnTagTypeMismatch = false) : FromCtx(FromCtx), ToCtx(ToCtx), NonEquivalentDecls(NonEquivalentDecls), StrictTypeSpelling(StrictTypeSpelling), - ErrorOnTagTypeMismatch(ErrorOnTagTypeMismatch), Complain(Complain), - LastDiagFromC2(false) {} + ErrorOnTagTypeMismatch(ErrorOnTagTypeMismatch), Complain(Complain) {} DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID); DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID); @@ -98,6 +98,7 @@ private: /// \returns true if an error occurred, false otherwise. bool Finish(); }; + } // namespace clang #endif // LLVM_CLANG_AST_ASTSTRUCTURALEQUIVALENCE_H diff --git a/clang/lib/AST/ASTStructuralEquivalence.cpp b/clang/lib/AST/ASTStructuralEquivalence.cpp index d74042c..618d27e 100644 --- a/clang/lib/AST/ASTStructuralEquivalence.cpp +++ b/clang/lib/AST/ASTStructuralEquivalence.cpp @@ -1,4 +1,4 @@ -//===--- ASTStructuralEquivalence.cpp - -------------------------*- C++ -*-===// +//===- ASTStructuralEquivalence.cpp ---------------------------------------===// // // The LLVM Compiler Infrastructure // @@ -15,15 +15,28 @@ #include "clang/AST/ASTStructuralEquivalence.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTDiagnostic.h" -#include "clang/AST/ASTImporter.h" +#include "clang/AST/Decl.h" +#include "clang/AST/DeclBase.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" -#include "clang/AST/DeclVisitor.h" -#include "clang/AST/StmtVisitor.h" -#include "clang/AST/TypeVisitor.h" -#include "clang/Basic/SourceManager.h" - -namespace { +#include "clang/AST/DeclTemplate.h" +#include "clang/AST/NestedNameSpecifier.h" +#include "clang/AST/TemplateBase.h" +#include "clang/AST/TemplateName.h" +#include "clang/AST/Type.h" +#include "clang/Basic/ExceptionSpecificationType.h" +#include "clang/Basic/IdentifierTable.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" +#include "llvm/ADT/APInt.h" +#include "llvm/ADT/APSInt.h" +#include "llvm/ADT/None.h" +#include "llvm/ADT/Optional.h" +#include "llvm/Support/Casting.h" +#include "llvm/Support/Compiler.h" +#include "llvm/Support/ErrorHandling.h" +#include +#include using namespace clang; @@ -144,6 +157,7 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, IsStructurallyEquivalent(Context, TS1->getReplacement(), TS2->getReplacement()); } + case TemplateName::SubstTemplateTemplateParmPack: { SubstTemplateTemplateParmPackStorage *P1 = N1.getAsSubstTemplateTemplateParmPack(), @@ -298,8 +312,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, case Type::LValueReference: case Type::RValueReference: { - const ReferenceType *Ref1 = cast(T1); - const ReferenceType *Ref2 = cast(T2); + const auto *Ref1 = cast(T1); + const auto *Ref2 = cast(T2); if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue()) return false; if (Ref1->isInnerRef() != Ref2->isInnerRef()) @@ -311,8 +325,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::MemberPointer: { - const MemberPointerType *MemPtr1 = cast(T1); - const MemberPointerType *MemPtr2 = cast(T2); + const auto *MemPtr1 = cast(T1); + const auto *MemPtr2 = cast(T2); if (!IsStructurallyEquivalent(Context, MemPtr1->getPointeeType(), MemPtr2->getPointeeType())) return false; @@ -323,8 +337,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::ConstantArray: { - const ConstantArrayType *Array1 = cast(T1); - const ConstantArrayType *Array2 = cast(T2); + const auto *Array1 = cast(T1); + const auto *Array2 = cast(T2); if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize())) return false; @@ -340,8 +354,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, break; case Type::VariableArray: { - const VariableArrayType *Array1 = cast(T1); - const VariableArrayType *Array2 = cast(T2); + const auto *Array1 = cast(T1); + const auto *Array2 = cast(T2); if (!IsStructurallyEquivalent(Context, Array1->getSizeExpr(), Array2->getSizeExpr())) return false; @@ -353,8 +367,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::DependentSizedArray: { - const DependentSizedArrayType *Array1 = cast(T1); - const DependentSizedArrayType *Array2 = cast(T2); + const auto *Array1 = cast(T1); + const auto *Array2 = cast(T2); if (!IsStructurallyEquivalent(Context, Array1->getSizeExpr(), Array2->getSizeExpr())) return false; @@ -366,10 +380,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::DependentAddressSpace: { - const DependentAddressSpaceType *DepAddressSpace1 = - cast(T1); - const DependentAddressSpaceType *DepAddressSpace2 = - cast(T2); + const auto *DepAddressSpace1 = cast(T1); + const auto *DepAddressSpace2 = cast(T2); if (!IsStructurallyEquivalent(Context, DepAddressSpace1->getAddrSpaceExpr(), DepAddressSpace2->getAddrSpaceExpr())) return false; @@ -381,10 +393,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::DependentSizedExtVector: { - const DependentSizedExtVectorType *Vec1 = - cast(T1); - const DependentSizedExtVectorType *Vec2 = - cast(T2); + const auto *Vec1 = cast(T1); + const auto *Vec2 = cast(T2); if (!IsStructurallyEquivalent(Context, Vec1->getSizeExpr(), Vec2->getSizeExpr())) return false; @@ -396,8 +406,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, case Type::Vector: case Type::ExtVector: { - const VectorType *Vec1 = cast(T1); - const VectorType *Vec2 = cast(T2); + const auto *Vec1 = cast(T1); + const auto *Vec2 = cast(T2); if (!IsStructurallyEquivalent(Context, Vec1->getElementType(), Vec2->getElementType())) return false; @@ -409,8 +419,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::FunctionProto: { - const FunctionProtoType *Proto1 = cast(T1); - const FunctionProtoType *Proto2 = cast(T2); + const auto *Proto1 = cast(T1); + const auto *Proto2 = cast(T2); if (Proto1->getNumParams() != Proto2->getNumParams()) return false; for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) { @@ -443,8 +453,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::FunctionNoProto: { - const FunctionType *Function1 = cast(T1); - const FunctionType *Function2 = cast(T2); + const auto *Function1 = cast(T1); + const auto *Function2 = cast(T2); if (!IsStructurallyEquivalent(Context, Function1->getReturnType(), Function2->getReturnType())) return false; @@ -458,7 +468,6 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, cast(T1)->getDecl(), cast(T2)->getDecl())) return false; - break; case Type::Attributed: @@ -519,8 +528,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, break; case Type::DeducedTemplateSpecialization: { - auto *DT1 = cast(T1); - auto *DT2 = cast(T2); + const auto *DT1 = cast(T1); + const auto *DT2 = cast(T2); if (!IsStructurallyEquivalent(Context, DT1->getTemplateName(), DT2->getTemplateName())) return false; @@ -538,8 +547,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, break; case Type::TemplateTypeParm: { - const TemplateTypeParmType *Parm1 = cast(T1); - const TemplateTypeParmType *Parm2 = cast(T2); + const auto *Parm1 = cast(T1); + const auto *Parm2 = cast(T2); if (Parm1->getDepth() != Parm2->getDepth()) return false; if (Parm1->getIndex() != Parm2->getIndex()) @@ -552,10 +561,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::SubstTemplateTypeParm: { - const SubstTemplateTypeParmType *Subst1 = - cast(T1); - const SubstTemplateTypeParmType *Subst2 = - cast(T2); + const auto *Subst1 = cast(T1); + const auto *Subst2 = cast(T2); if (!IsStructurallyEquivalent(Context, QualType(Subst1->getReplacedParameter(), 0), QualType(Subst2->getReplacedParameter(), 0))) @@ -567,10 +574,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::SubstTemplateTypeParmPack: { - const SubstTemplateTypeParmPackType *Subst1 = - cast(T1); - const SubstTemplateTypeParmPackType *Subst2 = - cast(T2); + const auto *Subst1 = cast(T1); + const auto *Subst2 = cast(T2); if (!IsStructurallyEquivalent(Context, QualType(Subst1->getReplacedParameter(), 0), QualType(Subst2->getReplacedParameter(), 0))) @@ -580,11 +585,10 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, return false; break; } + case Type::TemplateSpecialization: { - const TemplateSpecializationType *Spec1 = - cast(T1); - const TemplateSpecializationType *Spec2 = - cast(T2); + const auto *Spec1 = cast(T1); + const auto *Spec2 = cast(T2); if (!IsStructurallyEquivalent(Context, Spec1->getTemplateName(), Spec2->getTemplateName())) return false; @@ -599,8 +603,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::Elaborated: { - const ElaboratedType *Elab1 = cast(T1); - const ElaboratedType *Elab2 = cast(T2); + const auto *Elab1 = cast(T1); + const auto *Elab2 = cast(T2); // CHECKME: what if a keyword is ETK_None or ETK_typename ? if (Elab1->getKeyword() != Elab2->getKeyword()) return false; @@ -614,8 +618,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::InjectedClassName: { - const InjectedClassNameType *Inj1 = cast(T1); - const InjectedClassNameType *Inj2 = cast(T2); + const auto *Inj1 = cast(T1); + const auto *Inj2 = cast(T2); if (!IsStructurallyEquivalent(Context, Inj1->getInjectedSpecializationType(), Inj2->getInjectedSpecializationType())) @@ -624,8 +628,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::DependentName: { - const DependentNameType *Typename1 = cast(T1); - const DependentNameType *Typename2 = cast(T2); + const auto *Typename1 = cast(T1); + const auto *Typename2 = cast(T2); if (!IsStructurallyEquivalent(Context, Typename1->getQualifier(), Typename2->getQualifier())) return false; @@ -637,10 +641,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::DependentTemplateSpecialization: { - const DependentTemplateSpecializationType *Spec1 = - cast(T1); - const DependentTemplateSpecializationType *Spec2 = - cast(T2); + const auto *Spec1 = cast(T1); + const auto *Spec2 = cast(T2); if (!IsStructurallyEquivalent(Context, Spec1->getQualifier(), Spec2->getQualifier())) return false; @@ -665,8 +667,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, break; case Type::ObjCInterface: { - const ObjCInterfaceType *Iface1 = cast(T1); - const ObjCInterfaceType *Iface2 = cast(T2); + const auto *Iface1 = cast(T1); + const auto *Iface2 = cast(T2); if (!IsStructurallyEquivalent(Context, Iface1->getDecl(), Iface2->getDecl())) return false; @@ -674,8 +676,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::ObjCTypeParam: { - const ObjCTypeParamType *Obj1 = cast(T1); - const ObjCTypeParamType *Obj2 = cast(T2); + const auto *Obj1 = cast(T1); + const auto *Obj2 = cast(T2); if (!IsStructurallyEquivalent(Context, Obj1->getDecl(), Obj2->getDecl())) return false; @@ -688,9 +690,10 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } break; } + case Type::ObjCObject: { - const ObjCObjectType *Obj1 = cast(T1); - const ObjCObjectType *Obj2 = cast(T2); + const auto *Obj1 = cast(T1); + const auto *Obj2 = cast(T2); if (!IsStructurallyEquivalent(Context, Obj1->getBaseType(), Obj2->getBaseType())) return false; @@ -705,28 +708,25 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } case Type::ObjCObjectPointer: { - const ObjCObjectPointerType *Ptr1 = cast(T1); - const ObjCObjectPointerType *Ptr2 = cast(T2); + const auto *Ptr1 = cast(T1); + const auto *Ptr2 = cast(T2); if (!IsStructurallyEquivalent(Context, Ptr1->getPointeeType(), Ptr2->getPointeeType())) return false; break; } - case Type::Atomic: { + case Type::Atomic: if (!IsStructurallyEquivalent(Context, cast(T1)->getValueType(), cast(T2)->getValueType())) return false; break; - } - case Type::Pipe: { + case Type::Pipe: if (!IsStructurallyEquivalent(Context, cast(T1)->getElementType(), cast(T2)->getElementType())) return false; break; - } - } // end switch return true; @@ -735,7 +735,7 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, /// Determine structural equivalence of two fields. static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, FieldDecl *Field1, FieldDecl *Field2) { - RecordDecl *Owner2 = cast(Field2->getDeclContext()); + const auto *Owner2 = cast(Field2->getDeclContext()); // For anonymous structs/unions, match up the anonymous struct/union type // declarations directly, so that we don't go off searching for anonymous @@ -861,10 +861,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, // If both declarations are class template specializations, we know // the ODR applies, so check the template and template arguments. - ClassTemplateSpecializationDecl *Spec1 = - dyn_cast(D1); - ClassTemplateSpecializationDecl *Spec2 = - dyn_cast(D2); + const auto *Spec1 = dyn_cast(D1); + const auto *Spec2 = dyn_cast(D2); if (Spec1 && Spec2) { // Check that the specialized templates are the same. if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(), @@ -892,8 +890,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, if (!D1 || !D2) return true; - if (CXXRecordDecl *D1CXX = dyn_cast(D1)) { - if (CXXRecordDecl *D2CXX = dyn_cast(D2)) { + if (auto *D1CXX = dyn_cast(D1)) { + if (auto *D2CXX = dyn_cast(D2)) { if (D1CXX->hasExternalLexicalStorage() && !D1CXX->isCompleteDefinition()) { D1CXX->getASTContext().getExternalSource()->CompleteType(D1CXX); @@ -1082,10 +1080,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, } if (!Context.IsStructurallyEquivalent(Params1->getParam(I), - Params2->getParam(I))) { - + Params2->getParam(I))) return false; - } } return true; @@ -1209,9 +1205,6 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, Context.DeclsToCheck.push_back(D1->getCanonicalDecl()); return true; } -} // namespace - -namespace clang { DiagnosticBuilder StructuralEquivalenceContext::Diag1(SourceLocation Loc, unsigned DiagID) { @@ -1236,7 +1229,7 @@ StructuralEquivalenceContext::findUntaggedStructOrUnionIndex(RecordDecl *Anon) { ASTContext &Context = Anon->getASTContext(); QualType AnonTy = Context.getRecordType(Anon); - RecordDecl *Owner = dyn_cast(Anon->getDeclContext()); + const auto *Owner = dyn_cast(Anon->getDeclContext()); if (!Owner) return None; @@ -1303,8 +1296,8 @@ bool StructuralEquivalenceContext::Finish() { // FIXME: Switch on all declaration kinds. For now, we're just going to // check the obvious ones. - if (RecordDecl *Record1 = dyn_cast(D1)) { - if (RecordDecl *Record2 = dyn_cast(D2)) { + if (auto *Record1 = dyn_cast(D1)) { + if (auto *Record2 = dyn_cast(D2)) { // Check for equivalent structure names. IdentifierInfo *Name1 = Record1->getIdentifier(); if (!Name1 && Record1->getTypedefNameForAnonDecl()) @@ -1319,9 +1312,8 @@ bool StructuralEquivalenceContext::Finish() { // Record/non-record mismatch. Equivalent = false; } - - } else if (EnumDecl *Enum1 = dyn_cast(D1)) { - if (EnumDecl *Enum2 = dyn_cast(D2)) { + } else if (auto *Enum1 = dyn_cast(D1)) { + if (auto *Enum2 = dyn_cast(D2)) { // Check for equivalent enum names. IdentifierInfo *Name1 = Enum1->getIdentifier(); if (!Name1 && Enum1->getTypedefNameForAnonDecl()) @@ -1336,9 +1328,8 @@ bool StructuralEquivalenceContext::Finish() { // Enum/non-enum mismatch Equivalent = false; } - - } else if (TypedefNameDecl *Typedef1 = dyn_cast(D1)) { - if (TypedefNameDecl *Typedef2 = dyn_cast(D2)) { + } else if (const auto *Typedef1 = dyn_cast(D1)) { + if (const auto *Typedef2 = dyn_cast(D2)) { if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(), Typedef2->getIdentifier()) || !::IsStructurallyEquivalent(*this, Typedef1->getUnderlyingType(), @@ -1348,10 +1339,8 @@ bool StructuralEquivalenceContext::Finish() { // Typedef/non-typedef mismatch. Equivalent = false; } - - } else if (ClassTemplateDecl *ClassTemplate1 = - dyn_cast(D1)) { - if (ClassTemplateDecl *ClassTemplate2 = dyn_cast(D2)) { + } else if (auto *ClassTemplate1 = dyn_cast(D1)) { + if (auto *ClassTemplate2 = dyn_cast(D2)) { if (!::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2)) Equivalent = false; @@ -1359,11 +1348,8 @@ bool StructuralEquivalenceContext::Finish() { // Class template/non-class-template mismatch. Equivalent = false; } - - } else if (FunctionTemplateDecl *FunctionTemplate1 = - dyn_cast(D1)) { - if (FunctionTemplateDecl *FunctionTemplate2 = - dyn_cast(D2)) { + } else if (auto *FunctionTemplate1 = dyn_cast(D1)) { + if (auto *FunctionTemplate2 = dyn_cast(D2)) { if (!::IsStructurallyEquivalent(*this, FunctionTemplate1, FunctionTemplate2)) Equivalent = false; @@ -1371,31 +1357,24 @@ bool StructuralEquivalenceContext::Finish() { // Class template/non-class-template mismatch. Equivalent = false; } - - } else if (TemplateTypeParmDecl *TTP1 = - dyn_cast(D1)) { - if (TemplateTypeParmDecl *TTP2 = dyn_cast(D2)) { + } else if (auto *TTP1 = dyn_cast(D1)) { + if (auto *TTP2 = dyn_cast(D2)) { if (!::IsStructurallyEquivalent(*this, TTP1, TTP2)) Equivalent = false; } else { // Kind mismatch. Equivalent = false; } - } else if (NonTypeTemplateParmDecl *NTTP1 = - dyn_cast(D1)) { - if (NonTypeTemplateParmDecl *NTTP2 = - dyn_cast(D2)) { + } else if (auto *NTTP1 = dyn_cast(D1)) { + if (auto *NTTP2 = dyn_cast(D2)) { if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2)) Equivalent = false; } else { // Kind mismatch. Equivalent = false; } - - } else if (TemplateTemplateParmDecl *TTP1 = - dyn_cast(D1)) { - if (TemplateTemplateParmDecl *TTP2 = - dyn_cast(D2)) { + } else if (auto *TTP1 = dyn_cast(D1)) { + if (auto *TTP2 = dyn_cast(D2)) { if (!::IsStructurallyEquivalent(*this, TTP1, TTP2)) Equivalent = false; } else { @@ -1416,4 +1395,3 @@ bool StructuralEquivalenceContext::Finish() { return false; } -} // namespace clang diff --git a/clang/lib/AST/DeclBase.cpp b/clang/lib/AST/DeclBase.cpp index 04fd62f..baf83a3 100644 --- a/clang/lib/AST/DeclBase.cpp +++ b/clang/lib/AST/DeclBase.cpp @@ -101,7 +101,7 @@ void *Decl::operator new(std::size_t Size, const ASTContext &Ctx, // padding at the start if required. size_t ExtraAlign = llvm::OffsetToAlignment(sizeof(Module *), alignof(Decl)); - char *Buffer = reinterpret_cast( + auto *Buffer = reinterpret_cast( ::operator new(ExtraAlign + sizeof(Module *) + Size + Extra, Ctx)); Buffer += ExtraAlign; auto *ParentModule = @@ -145,8 +145,8 @@ void Decl::setInvalidDecl(bool Invalid) { // Marking a DecompositionDecl as invalid implies all the child BindingDecl's // are invalid too. - if (DecompositionDecl *DD = dyn_cast(this)) { - for (BindingDecl *Binding : DD->bindings()) { + if (auto *DD = dyn_cast(this)) { + for (auto *Binding : DD->bindings()) { Binding->setInvalidDecl(); } } @@ -199,28 +199,26 @@ void Decl::add(Kind k) { } bool Decl::isTemplateParameterPack() const { - if (const TemplateTypeParmDecl *TTP = dyn_cast(this)) + if (const auto *TTP = dyn_cast(this)) return TTP->isParameterPack(); - if (const NonTypeTemplateParmDecl *NTTP - = dyn_cast(this)) + if (const auto *NTTP = dyn_cast(this)) return NTTP->isParameterPack(); - if (const TemplateTemplateParmDecl *TTP - = dyn_cast(this)) + if (const auto *TTP = dyn_cast(this)) return TTP->isParameterPack(); return false; } bool Decl::isParameterPack() const { - if (const ParmVarDecl *Parm = dyn_cast(this)) + if (const auto *Parm = dyn_cast(this)) return Parm->isParameterPack(); return isTemplateParameterPack(); } FunctionDecl *Decl::getAsFunction() { - if (FunctionDecl *FD = dyn_cast(this)) + if (auto *FD = dyn_cast(this)) return FD; - if (const FunctionTemplateDecl *FTD = dyn_cast(this)) + if (const auto *FTD = dyn_cast(this)) return FTD->getTemplatedDecl(); return nullptr; } @@ -279,7 +277,7 @@ void PrettyStackTraceDecl::print(raw_ostream &OS) const { OS << Message; - if (const NamedDecl *DN = dyn_cast_or_null(TheDecl)) { + if (const auto *DN = dyn_cast_or_null(TheDecl)) { OS << " '"; DN->printQualifiedName(OS); OS << '\''; @@ -327,7 +325,7 @@ void Decl::setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC, if (SemaDC == LexicalDC) { DeclCtx = SemaDC; } else { - Decl::MultipleDC *MDC = new (Ctx) Decl::MultipleDC(); + auto *MDC = new (Ctx) Decl::MultipleDC(); MDC->SemanticDC = SemaDC; MDC->LexicalDC = LexicalDC; DeclCtx = MDC; @@ -348,7 +346,7 @@ bool Decl::isLexicallyWithinFunctionOrMethod() const { bool Decl::isInAnonymousNamespace() const { for (const DeclContext *DC = getDeclContext(); DC; DC = DC->getParent()) { - if (const NamespaceDecl *ND = dyn_cast(DC)) + if (const auto *ND = dyn_cast(DC)) if (ND->isAnonymousNamespace()) return true; } @@ -361,7 +359,7 @@ bool Decl::isInStdNamespace() const { } TranslationUnitDecl *Decl::getTranslationUnitDecl() { - if (TranslationUnitDecl *TUD = dyn_cast(this)) + if (auto *TUD = dyn_cast(this)) return TUD; DeclContext *DC = getDeclContext(); @@ -426,7 +424,7 @@ bool Decl::isReferenced() const { return true; // Check redeclarations. - for (auto I : redecls()) + for (const auto *I : redecls()) if (I->Referenced) return true; @@ -451,11 +449,11 @@ bool Decl::isExported() const { ExternalSourceSymbolAttr *Decl::getExternalSourceSymbolAttr() const { const Decl *Definition = nullptr; - if (auto ID = dyn_cast(this)) { + if (auto *ID = dyn_cast(this)) { Definition = ID->getDefinition(); - } else if (auto PD = dyn_cast(this)) { + } else if (auto *PD = dyn_cast(this)) { Definition = PD->getDefinition(); - } else if (auto TD = dyn_cast(this)) { + } else if (auto *TD = dyn_cast(this)) { Definition = TD->getDefinition(); } if (!Definition) @@ -475,9 +473,9 @@ bool Decl::hasDefiningAttr() const { } const Attr *Decl::getDefiningAttr() const { - if (AliasAttr *AA = getAttr()) + if (auto *AA = getAttr()) return AA; - if (IFuncAttr *IFA = getAttr()) + if (auto *IFA = getAttr()) return IFA; return nullptr; } @@ -649,14 +647,14 @@ VersionTuple Decl::getVersionIntroduced() const { return Availability->getIntroduced(); } } - return VersionTuple(); + return {}; } bool Decl::canBeWeakImported(bool &IsDefinition) const { IsDefinition = false; // Variables, if they aren't definitions. - if (const VarDecl *Var = dyn_cast(this)) { + if (const auto *Var = dyn_cast(this)) { if (Var->isThisDeclarationADefinition()) { IsDefinition = true; return false; @@ -664,7 +662,7 @@ bool Decl::canBeWeakImported(bool &IsDefinition) const { return true; // Functions, if they aren't definitions. - } else if (const FunctionDecl *FD = dyn_cast(this)) { + } else if (const auto *FD = dyn_cast(this)) { if (FD->hasBody()) { IsDefinition = true; return false; @@ -847,14 +845,14 @@ Decl *Decl::castFromDeclContext (const DeclContext *D) { #define DECL(NAME, BASE) #define DECL_CONTEXT(NAME) \ case Decl::NAME: \ - return static_cast(const_cast(D)); + return static_cast(const_cast(D)); #define DECL_CONTEXT_BASE(NAME) #include "clang/AST/DeclNodes.inc" default: #define DECL(NAME, BASE) #define DECL_CONTEXT_BASE(NAME) \ if (DK >= first##NAME && DK <= last##NAME) \ - return static_cast(const_cast(D)); + return static_cast(const_cast(D)); #include "clang/AST/DeclNodes.inc" llvm_unreachable("a decl that inherits DeclContext isn't handled"); } @@ -866,14 +864,14 @@ DeclContext *Decl::castToDeclContext(const Decl *D) { #define DECL(NAME, BASE) #define DECL_CONTEXT(NAME) \ case Decl::NAME: \ - return static_cast(const_cast(D)); + return static_cast(const_cast(D)); #define DECL_CONTEXT_BASE(NAME) #include "clang/AST/DeclNodes.inc" default: #define DECL(NAME, BASE) #define DECL_CONTEXT_BASE(NAME) \ if (DK >= first##NAME && DK <= last##NAME) \ - return static_cast(const_cast(D)); + return static_cast(const_cast(D)); #include "clang/AST/DeclNodes.inc" llvm_unreachable("a decl that inherits DeclContext isn't handled"); } @@ -882,17 +880,17 @@ DeclContext *Decl::castToDeclContext(const Decl *D) { SourceLocation Decl::getBodyRBrace() const { // Special handling of FunctionDecl to avoid de-serializing the body from PCH. // FunctionDecl stores EndRangeLoc for this purpose. - if (const FunctionDecl *FD = dyn_cast(this)) { + if (const auto *FD = dyn_cast(this)) { const FunctionDecl *Definition; if (FD->hasBody(Definition)) return Definition->getSourceRange().getEnd(); - return SourceLocation(); + return {}; } if (Stmt *Body = getBody()) return Body->getSourceRange().getEnd(); - return SourceLocation(); + return {}; } bool Decl::AccessDeclContextSanity() const { @@ -932,9 +930,9 @@ static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); } const FunctionType *Decl::getFunctionType(bool BlocksToo) const { QualType Ty; - if (const ValueDecl *D = dyn_cast(this)) + if (const auto *D = dyn_cast(this)) Ty = D->getType(); - else if (const TypedefNameDecl *D = dyn_cast(this)) + else if (const auto *D = dyn_cast(this)) Ty = D->getUnderlyingType(); else return nullptr; @@ -951,22 +949,21 @@ const FunctionType *Decl::getFunctionType(bool BlocksToo) const { /// code context that is not a closure (a lambda, block, etc.). template static Decl *getNonClosureContext(T *D) { if (getKind(D) == Decl::CXXMethod) { - CXXMethodDecl *MD = cast(D); + auto *MD = cast(D); if (MD->getOverloadedOperator() == OO_Call && MD->getParent()->isLambda()) return getNonClosureContext(MD->getParent()->getParent()); return MD; - } else if (FunctionDecl *FD = dyn_cast(D)) { + } else if (auto *FD = dyn_cast(D)) return FD; - } else if (ObjCMethodDecl *MD = dyn_cast(D)) { + else if (auto *MD = dyn_cast(D)) return MD; - } else if (BlockDecl *BD = dyn_cast(D)) { + else if (auto *BD = dyn_cast(D)) return getNonClosureContext(BD->getParent()); - } else if (CapturedDecl *CD = dyn_cast(D)) { + else if (auto *CD = dyn_cast(D)) return getNonClosureContext(CD->getParent()); - } else { + else return nullptr; - } } Decl *Decl::getNonClosureContext() { @@ -1026,7 +1023,7 @@ bool DeclContext::isStdNamespace() const { if (!isNamespace()) return false; - const NamespaceDecl *ND = cast(this); + const auto *ND = cast(this); if (ND->isInline()) { return ND->getParent()->isStdNamespace(); } @@ -1045,7 +1042,7 @@ bool DeclContext::isDependentContext() const { if (isa(this)) return true; - if (const CXXRecordDecl *Record = dyn_cast(this)) { + if (const auto *Record = dyn_cast(this)) { if (Record->getDescribedClassTemplate()) return true; @@ -1053,7 +1050,7 @@ bool DeclContext::isDependentContext() const { return true; } - if (const FunctionDecl *Function = dyn_cast(this)) { + if (const auto *Function = dyn_cast(this)) { if (Function->getDescribedFunctionTemplate()) return true; @@ -1132,18 +1129,18 @@ DeclContext *DeclContext::getPrimaryContext() { case Decl::Namespace: // The original namespace is our primary context. - return static_cast(this)->getOriginalNamespace(); + return static_cast(this)->getOriginalNamespace(); case Decl::ObjCMethod: return this; case Decl::ObjCInterface: - if (ObjCInterfaceDecl *Def = cast(this)->getDefinition()) + if (auto *Def = cast(this)->getDefinition()) return Def; return this; case Decl::ObjCProtocol: - if (ObjCProtocolDecl *Def = cast(this)->getDefinition()) + if (auto *Def = cast(this)->getDefinition()) return Def; return this; @@ -1158,12 +1155,12 @@ DeclContext *DeclContext::getPrimaryContext() { if (DeclKind >= Decl::firstTag && DeclKind <= Decl::lastTag) { // If this is a tag type that has a definition or is currently // being defined, that definition is our primary context. - TagDecl *Tag = cast(this); + auto *Tag = cast(this); if (TagDecl *Def = Tag->getDefinition()) return Def; - if (const TagType *TagTy = dyn_cast(Tag->getTypeForDecl())) { + if (const auto *TagTy = dyn_cast(Tag->getTypeForDecl())) { // Note, TagType::getDecl returns the (partial) definition one exists. TagDecl *PossiblePartialDef = TagTy->getDecl(); if (PossiblePartialDef->isBeingDefined()) @@ -1190,7 +1187,7 @@ DeclContext::collectAllContexts(SmallVectorImpl &Contexts){ return; } - NamespaceDecl *Self = static_cast(this); + auto *Self = static_cast(this); for (NamespaceDecl *N = Self->getMostRecentDecl(); N; N = N->getPreviousDecl()) Contexts.push_back(N); @@ -1199,16 +1196,15 @@ DeclContext::collectAllContexts(SmallVectorImpl &Contexts){ } std::pair -DeclContext::BuildDeclChain(ArrayRef Decls, +DeclContext::BuildDeclChain(ArrayRef Decls, bool FieldsAlreadyLoaded) { // Build up a chain of declarations via the Decl::NextInContextAndBits field. Decl *FirstNewDecl = nullptr; Decl *PrevDecl = nullptr; - for (unsigned I = 0, N = Decls.size(); I != N; ++I) { - if (FieldsAlreadyLoaded && isa(Decls[I])) + for (auto *D : Decls) { + if (FieldsAlreadyLoaded && isa(D)) continue; - Decl *D = Decls[I]; if (PrevDecl) PrevDecl->NextInContextAndBits.setPointer(D); else @@ -1253,7 +1249,7 @@ DeclContext::LoadLexicalDeclsFromExternalStorage() const { // We may have already loaded just the fields of this record, in which case // we need to ignore them. bool FieldsAlreadyLoaded = false; - if (const RecordDecl *RD = dyn_cast(this)) + if (const auto *RD = dyn_cast(this)) FieldsAlreadyLoaded = RD->LoadedFieldsFromExternalStorage; // Splice the newly-read declarations into the beginning of the list @@ -1320,12 +1316,11 @@ ExternalASTSource::SetExternalVisibleDeclsForName(const DeclContext *DC, } } else { // Convert the array to a StoredDeclsList. - for (ArrayRef::iterator - I = Decls.begin(), E = Decls.end(); I != E; ++I) { + for (auto *D : Decls) { if (List.isNull()) - List.setOnlyValue(*I); + List.setOnlyValue(D); else - List.AddSubsequentDecl(*I); + List.AddSubsequentDecl(D); } } @@ -1378,7 +1373,7 @@ void DeclContext::removeDecl(Decl *D) { // Remove D from the lookup table if necessary. if (isa(D)) { - NamedDecl *ND = cast(D); + auto *ND = cast(D); // Remove only decls that have a name if (!ND->getDeclName()) return; @@ -1411,13 +1406,13 @@ void DeclContext::addHiddenDecl(Decl *D) { // Notify a C++ record declaration that we've added a member, so it can // update its class-specific state. - if (CXXRecordDecl *Record = dyn_cast(this)) + if (auto *Record = dyn_cast(this)) Record->addedMember(D); // If this is a newly-created (not de-serialized) import declaration, wire // it in to the list of local import declarations. if (!D->isFromASTFile()) { - if (ImportDecl *Import = dyn_cast(D)) + if (auto *Import = dyn_cast(D)) D->getASTContext().addedLocalImportDecl(Import); } } @@ -1425,7 +1420,7 @@ void DeclContext::addHiddenDecl(Decl *D) { void DeclContext::addDecl(Decl *D) { addHiddenDecl(D); - if (NamedDecl *ND = dyn_cast(D)) + if (auto *ND = dyn_cast(D)) ND->getDeclContext()->getPrimaryContext()-> makeDeclVisibleInContextWithFlags(ND, false, true); } @@ -1433,7 +1428,7 @@ void DeclContext::addDecl(Decl *D) { void DeclContext::addDeclInternal(Decl *D) { addHiddenDecl(D); - if (NamedDecl *ND = dyn_cast(D)) + if (auto *ND = dyn_cast(D)) ND->getDeclContext()->getPrimaryContext()-> makeDeclVisibleInContextWithFlags(ND, true, true); } @@ -1457,7 +1452,7 @@ static bool shouldBeHidden(NamedDecl *D) { // from being visible? if (isa(D)) return true; - if (FunctionDecl *FD = dyn_cast(D)) + if (auto *FD = dyn_cast(D)) if (FD->isFunctionTemplateSpecialization()) return true; @@ -1505,7 +1500,7 @@ StoredDeclsMap *DeclContext::buildLookup() { /// DeclContext, a DeclContext linked to it, or a transparent context /// nested within it. void DeclContext::buildLookupImpl(DeclContext *DCtx, bool Internal) { - for (Decl *D : DCtx->noload_decls()) { + for (auto *D : DCtx->noload_decls()) { // Insert this declaration into the lookup structure, but only if // it's semantically within its decl context. Any other decls which // should be found in this context are added eagerly. @@ -1514,7 +1509,7 @@ void DeclContext::buildLookupImpl(DeclContext *DCtx, bool Internal) { // FindExternalVisibleDeclsByName if needed. Exception: if we're not // in C++, we do not track external visible decls for the TU, so in // that case we need to collect them all here. - if (NamedDecl *ND = dyn_cast(D)) + if (auto *ND = dyn_cast(D)) if (ND->getDeclContext() == DCtx && !shouldBeHidden(ND) && (!ND->isFromASTFile() || (isTranslationUnit() && @@ -1524,7 +1519,7 @@ void DeclContext::buildLookupImpl(DeclContext *DCtx, bool Internal) { // If this declaration is itself a transparent declaration context // or inline namespace, add the members of this declaration of that // context (recursively). - if (DeclContext *InnerCtx = dyn_cast(D)) + if (auto *InnerCtx = dyn_cast(D)) if (InnerCtx->isTransparentContext() || InnerCtx->isInlineNamespace()) buildLookupImpl(InnerCtx, Internal); } @@ -1577,7 +1572,7 @@ DeclContext::lookup(DeclarationName Name) const { } } - return lookup_result(); + return {}; } StoredDeclsMap *Map = LookupPtr; @@ -1585,11 +1580,11 @@ DeclContext::lookup(DeclarationName Name) const { Map = const_cast(this)->buildLookup(); if (!Map) - return lookup_result(); + return {}; StoredDeclsMap::iterator I = Map->find(Name); if (I == Map->end()) - return lookup_result(); + return {}; return I->second.getLookupResult(); } @@ -1606,7 +1601,7 @@ DeclContext::noload_lookup(DeclarationName Name) { loadLazyLocalLexicalLookups(); StoredDeclsMap *Map = LookupPtr; if (!Map) - return lookup_result(); + return {}; StoredDeclsMap::iterator I = Map->find(Name); return I != Map->end() ? I->second.getLookupResult() @@ -1620,8 +1615,8 @@ void DeclContext::loadLazyLocalLexicalLookups() { if (HasLazyLocalLexicalLookups) { SmallVector Contexts; collectAllContexts(Contexts); - for (unsigned I = 0, N = Contexts.size(); I != N; ++I) - buildLookupImpl(Contexts[I], hasExternalVisibleStorage()); + for (auto *Context : Contexts) + buildLookupImpl(Context, hasExternalVisibleStorage()); HasLazyLocalLexicalLookups = false; } } @@ -1657,7 +1652,7 @@ void DeclContext::localUncachedLookup(DeclarationName Name, // FIXME: If we have lazy external declarations, this will not find them! // FIXME: Should we CollectAllContexts and walk them all here? for (Decl *D = FirstDecl; D; D = D->getNextDeclInContext()) { - if (NamedDecl *ND = dyn_cast(D)) + if (auto *ND = dyn_cast(D)) if (ND->getDeclName() == Name) Results.push_back(ND); } @@ -1699,7 +1694,7 @@ bool DeclContext::InEnclosingNamespaceSetOf(const DeclContext *O) const { if (O->Equals(this)) return true; - const NamespaceDecl *NS = dyn_cast(O); + const auto *NS = dyn_cast(O); if (!NS || !NS->isInline()) break; O = NS->getParent(); @@ -1758,7 +1753,7 @@ void DeclContext::makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal, getParent()->getPrimaryContext()-> makeDeclVisibleInContextWithFlags(D, Internal, Recoverable); - Decl *DCAsDecl = cast(this); + auto *DCAsDecl = cast(this); // Notify that a decl was made visible unless we are a Tag being defined. if (!(isa(DCAsDecl) && cast(DCAsDecl)->isBeingDefined())) if (ASTMutationListener *L = DCAsDecl->getASTMutationListener()) @@ -1876,8 +1871,7 @@ DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C, if (!Parent->LookupPtr) Parent->CreateStoredDeclsMap(C); - DependentStoredDeclsMap *Map = - static_cast(Parent->LookupPtr); + auto *Map = static_cast(Parent->LookupPtr); // Allocate the copy of the PartialDiagnostic via the ASTContext's // BumpPtrAllocator, rather than the ASTContext itself. @@ -1885,7 +1879,7 @@ DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C, if (PDiag.hasStorage()) DiagStorage = new (C) PartialDiagnostic::Storage; - DependentDiagnostic *DD = new (C) DependentDiagnostic(PDiag, DiagStorage); + auto *DD = new (C) DependentDiagnostic(PDiag, DiagStorage); // TODO: Maybe we shouldn't reverse the order during insertion. DD->NextDiagnostic = Map->FirstDiagnostic; diff --git a/clang/lib/AST/DeclObjC.cpp b/clang/lib/AST/DeclObjC.cpp index af6c16d..16e063c 100644 --- a/clang/lib/AST/DeclObjC.cpp +++ b/clang/lib/AST/DeclObjC.cpp @@ -74,7 +74,7 @@ ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const { lookup_result R = lookup(Id); for (lookup_iterator Ivar = R.begin(), IvarEnd = R.end(); Ivar != IvarEnd; ++Ivar) { - if (ObjCIvarDecl *ivar = dyn_cast(*Ivar)) + if (auto *ivar = dyn_cast(*Ivar)) return ivar; } return nullptr; @@ -86,7 +86,7 @@ ObjCContainerDecl::getMethod(Selector Sel, bool isInstance, bool AllowHidden) const { // If this context is a hidden protocol definition, don't find any // methods there. - if (const ObjCProtocolDecl *Proto = dyn_cast(this)) { + if (const auto *Proto = dyn_cast(this)) { if (const ObjCProtocolDecl *Def = Proto->getDefinition()) if (Def->isHidden() && !AllowHidden) return nullptr; @@ -102,7 +102,7 @@ ObjCContainerDecl::getMethod(Selector Sel, bool isInstance, lookup_result R = lookup(Sel); for (lookup_iterator Meth = R.begin(), MethEnd = R.end(); Meth != MethEnd; ++Meth) { - ObjCMethodDecl *MD = dyn_cast(*Meth); + auto *MD = dyn_cast(*Meth); if (MD && MD->isInstanceMethod() == isInstance) return MD; } @@ -120,12 +120,12 @@ bool ObjCContainerDecl::HasUserDeclaredSetterMethod( lookup_result R = lookup(Sel); for (lookup_iterator Meth = R.begin(), MethEnd = R.end(); Meth != MethEnd; ++Meth) { - ObjCMethodDecl *MD = dyn_cast(*Meth); + auto *MD = dyn_cast(*Meth); if (MD && MD->isInstanceMethod() && !MD->isImplicit()) return true; } - if (const ObjCInterfaceDecl *ID = dyn_cast(this)) { + if (const auto *ID = dyn_cast(this)) { // Also look into categories, including class extensions, looking // for a user declared instance method. for (const auto *Cat : ID->visible_categories()) { @@ -159,7 +159,7 @@ bool ObjCContainerDecl::HasUserDeclaredSetterMethod( OSC = OSC->getSuperClass(); } } - if (const ObjCProtocolDecl *PD = dyn_cast(this)) + if (const auto *PD = dyn_cast(this)) for (const auto *PI : PD->protocols()) if (PI->HasUserDeclaredSetterMethod(Property)) return true; @@ -172,7 +172,7 @@ ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC, ObjCPropertyQueryKind queryKind) { // If this context is a hidden protocol definition, don't find any // property. - if (const ObjCProtocolDecl *Proto = dyn_cast(DC)) { + if (const auto *Proto = dyn_cast(DC)) { if (const ObjCProtocolDecl *Def = Proto->getDefinition()) if (Def->isHidden()) return nullptr; @@ -192,7 +192,7 @@ ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC, ObjCPropertyDecl *classProp = nullptr; for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) - if (ObjCPropertyDecl *PD = dyn_cast(*I)) { + if (auto *PD = dyn_cast(*I)) { // If queryKind is unknown, we return the instance property if one // exists; otherwise we return the class property. if ((queryKind == ObjCPropertyQueryKind::OBJC_PR_query_unknown && @@ -230,7 +230,7 @@ ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration( const IdentifierInfo *PropertyId, ObjCPropertyQueryKind QueryKind) const { // Don't find properties within hidden protocol definitions. - if (const ObjCProtocolDecl *Proto = dyn_cast(this)) { + if (const auto *Proto = dyn_cast(this)) { if (const ObjCProtocolDecl *Def = Proto->getDefinition()) if (Def->isHidden()) return nullptr; @@ -254,7 +254,7 @@ ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration( default: break; case Decl::ObjCProtocol: { - const ObjCProtocolDecl *PID = cast(this); + const auto *PID = cast(this); for (const auto *I : PID->protocols()) if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId, QueryKind)) @@ -262,7 +262,7 @@ ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration( break; } case Decl::ObjCInterface: { - const ObjCInterfaceDecl *OID = cast(this); + const auto *OID = cast(this); // Look through categories (but not extensions; they were handled above). for (const auto *Cat : OID->visible_categories()) { if (!Cat->IsClassExtension()) @@ -283,7 +283,7 @@ ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration( break; } case Decl::ObjCCategory: { - const ObjCCategoryDecl *OCD = cast(this); + const auto *OCD = cast(this); // Look through protocols. if (!OCD->IsClassExtension()) for (const auto *I : OCD->protocols()) @@ -310,7 +310,8 @@ ObjCTypeParamList *ObjCInterfaceDecl::getTypeParamList() const { // Otherwise, look at previous declarations to determine whether any // of them has a type parameter list, skipping over those // declarations that do not. - for (auto decl = getMostRecentDecl(); decl; decl = decl->getPreviousDecl()) { + for (const ObjCInterfaceDecl *decl = getMostRecentDecl(); decl; + decl = decl->getPreviousDecl()) { if (ObjCTypeParamList *written = decl->getTypeParamListAsWritten()) return written; } @@ -323,7 +324,7 @@ void ObjCInterfaceDecl::setTypeParamList(ObjCTypeParamList *TPL) { if (!TPL) return; // Set the declaration context of each of the type parameters. - for (auto typeParam : *TypeParamList) + for (auto *typeParam : *TypeParamList) typeParam->setDeclContext(this); } @@ -437,7 +438,7 @@ void ObjCInterfaceDecl::mergeClassExtensionProtocolList( // Check for duplicate protocol in class's protocol list. // This is O(n*m). But it is extremely rare and number of protocols in // class or its extension are very few. - SmallVector ProtocolRefs; + SmallVector ProtocolRefs; for (unsigned i = 0; i < ExtNum; i++) { bool protocolExists = false; ObjCProtocolDecl *ProtoInExtension = ExtList[i]; @@ -604,7 +605,7 @@ void ObjCInterfaceDecl::startDefinition() { allocateDefinitionData(); // Update all of the declarations with a pointer to the definition. - for (auto RD : redecls()) { + for (auto *RD : redecls()) { if (RD != this) RD->Data = Data; } @@ -710,9 +711,8 @@ ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel, // Didn't find one yet - look through protocols. const ObjCList &Protocols = Cat->getReferencedProtocols(); - for (ObjCList::iterator I = Protocols.begin(), - E = Protocols.end(); I != E; ++I) - if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance))) + for (auto *Protocol : Protocols) + if ((MethodDecl = Protocol->lookupMethod(Sel, isInstance))) if (C != Cat || !MethodDecl->isImplicit()) return MethodDecl; } @@ -865,27 +865,25 @@ ObjCMethodDecl *ObjCMethodDecl::getNextRedeclarationImpl() { if (Redecl) return Redecl; - Decl *CtxD = cast(getDeclContext()); + auto *CtxD = cast(getDeclContext()); if (!CtxD->isInvalidDecl()) { - if (ObjCInterfaceDecl *IFD = dyn_cast(CtxD)) { + if (auto *IFD = dyn_cast(CtxD)) { if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD)) if (!ImplD->isInvalidDecl()) Redecl = ImplD->getMethod(getSelector(), isInstanceMethod()); - } else if (ObjCCategoryDecl *CD = dyn_cast(CtxD)) { + } else if (auto *CD = dyn_cast(CtxD)) { if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD)) if (!ImplD->isInvalidDecl()) Redecl = ImplD->getMethod(getSelector(), isInstanceMethod()); - } else if (ObjCImplementationDecl *ImplD = - dyn_cast(CtxD)) { + } else if (auto *ImplD = dyn_cast(CtxD)) { if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) if (!IFD->isInvalidDecl()) Redecl = IFD->getMethod(getSelector(), isInstanceMethod()); - } else if (ObjCCategoryImplDecl *CImplD = - dyn_cast(CtxD)) { + } else if (auto *CImplD = dyn_cast(CtxD)) { if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl()) if (!CatD->isInvalidDecl()) Redecl = CatD->getMethod(getSelector(), isInstanceMethod()); @@ -908,15 +906,14 @@ ObjCMethodDecl *ObjCMethodDecl::getNextRedeclarationImpl() { } ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() { - Decl *CtxD = cast(getDeclContext()); + auto *CtxD = cast(getDeclContext()); - if (ObjCImplementationDecl *ImplD = dyn_cast(CtxD)) { + if (auto *ImplD = dyn_cast(CtxD)) { if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(), isInstanceMethod())) return MD; - } else if (ObjCCategoryImplDecl *CImplD = - dyn_cast(CtxD)) { + } else if (auto *CImplD = dyn_cast(CtxD)) { if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl()) if (ObjCMethodDecl *MD = CatD->getMethod(getSelector(), isInstanceMethod())) @@ -941,7 +938,7 @@ SourceLocation ObjCMethodDecl::getLocEnd() const { } ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const { - ObjCMethodFamily family = static_cast(Family); + auto family = static_cast(Family); if (family != static_cast(InvalidObjCMethodFamily)) return family; @@ -1099,11 +1096,11 @@ void ObjCMethodDecl::createImplicitParams(ASTContext &Context, } ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() { - if (ObjCInterfaceDecl *ID = dyn_cast(getDeclContext())) + if (auto *ID = dyn_cast(getDeclContext())) return ID; - if (ObjCCategoryDecl *CD = dyn_cast(getDeclContext())) + if (auto *CD = dyn_cast(getDeclContext())) return CD->getClassInterface(); - if (ObjCImplDecl *IMD = dyn_cast(getDeclContext())) + if (auto *IMD = dyn_cast(getDeclContext())) return IMD->getClassInterface(); if (isa(getDeclContext())) return nullptr; @@ -1141,8 +1138,7 @@ static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container, // In categories look for overridden methods from protocols. A method from // category is not "overridden" since it is considered as the "same" method // (same USR) as the one from the interface. - if (const ObjCCategoryDecl * - Category = dyn_cast(Container)) { + if (const auto *Category = dyn_cast(Container)) { // Check whether we have a matching method at this category but only if we // are at the super class level. if (MovedToSuper) @@ -1174,13 +1170,12 @@ static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container, return; } - if (const ObjCProtocolDecl *Protocol = dyn_cast(Container)){ + if (const auto *Protocol = dyn_cast(Container)){ for (const auto *P : Protocol->protocols()) CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper); } - if (const ObjCInterfaceDecl * - Interface = dyn_cast(Container)) { + if (const auto *Interface = dyn_cast(Container)) { for (const auto *P : Interface->protocols()) CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper); @@ -1204,12 +1199,12 @@ static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method, SmallVectorImpl &overridden) { assert(Method->isOverriding()); - if (const ObjCProtocolDecl * - ProtD = dyn_cast(Method->getDeclContext())) { + if (const auto *ProtD = + dyn_cast(Method->getDeclContext())) { CollectOverriddenMethods(ProtD, Method, overridden); - } else if (const ObjCImplDecl * - IMD = dyn_cast(Method->getDeclContext())) { + } else if (const auto *IMD = + dyn_cast(Method->getDeclContext())) { const ObjCInterfaceDecl *ID = IMD->getClassInterface(); if (!ID) return; @@ -1221,8 +1216,8 @@ static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method, Method = IFaceMeth; CollectOverriddenMethods(ID, Method, overridden); - } else if (const ObjCCategoryDecl * - CatD = dyn_cast(Method->getDeclContext())) { + } else if (const auto *CatD = + dyn_cast(Method->getDeclContext())) { const ObjCInterfaceDecl *ID = CatD->getClassInterface(); if (!ID) return; @@ -1265,7 +1260,7 @@ ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const { return nullptr; if (isPropertyAccessor()) { - const ObjCContainerDecl *Container = cast(getParent()); + const auto *Container = cast(getParent()); bool IsGetter = (NumArgs == 0); bool IsInstance = isInstanceMethod(); @@ -1328,11 +1323,9 @@ ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const { OverridesTy Overrides; getOverriddenMethods(Overrides); - for (OverridesTy::const_iterator I = Overrides.begin(), E = Overrides.end(); - I != E; ++I) { - if (const ObjCPropertyDecl *Prop = (*I)->findPropertyDecl(false)) + for (const auto *Override : Overrides) + if (const ObjCPropertyDecl *Prop = Override->findPropertyDecl(false)) return Prop; - } return nullptr; } @@ -1422,7 +1415,7 @@ ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C, ObjCInterfaceDecl *PrevDecl, SourceLocation ClassLoc, bool isInternal){ - ObjCInterfaceDecl *Result = new (C, DC) + auto *Result = new (C, DC) ObjCInterfaceDecl(C, DC, atLoc, Id, typeParamList, ClassLoc, PrevDecl, isInternal); Result->Data.setInt(!C.getLangOpts().Modules); @@ -1432,12 +1425,9 @@ ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C, ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(const ASTContext &C, unsigned ID) { - ObjCInterfaceDecl *Result = new (C, ID) ObjCInterfaceDecl(C, nullptr, - SourceLocation(), - nullptr, - nullptr, - SourceLocation(), - nullptr, false); + auto *Result = new (C, ID) + ObjCInterfaceDecl(C, nullptr, SourceLocation(), nullptr, nullptr, + SourceLocation(), nullptr, false); Result->Data.setInt(!C.getLangOpts().Modules); return Result; } @@ -1495,7 +1485,7 @@ bool ObjCInterfaceDecl::hasDesignatedInitializers() const { StringRef ObjCInterfaceDecl::getObjCRuntimeNameAsString() const { - if (ObjCRuntimeNameAttr *ObjCRTName = getAttr()) + if (const auto *ObjCRTName = getAttr()) return ObjCRTName->getMetadataName(); return getName(); @@ -1731,9 +1721,9 @@ ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC, "Invalid ivar decl context!"); // Once a new ivar is created in any of class/class-extension/implementation // decl contexts, the previously built IvarList must be rebuilt. - ObjCInterfaceDecl *ID = dyn_cast(DC); + auto *ID = dyn_cast(DC); if (!ID) { - if (ObjCImplementationDecl *IM = dyn_cast(DC)) + if (auto *IM = dyn_cast(DC)) ID = IM->getClassInterface(); else ID = cast(DC)->getClassInterface(); @@ -1752,7 +1742,7 @@ ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, unsigned ID) { } const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const { - const ObjCContainerDecl *DC = cast(getDeclContext()); + const auto *DC = cast(getDeclContext()); switch (DC->getKind()) { default: @@ -1762,7 +1752,7 @@ const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const { // Ivars can only appear in class extension categories. case ObjCCategory: { - const ObjCCategoryDecl *CD = cast(DC); + const auto *CD = cast(DC); assert(CD->IsClassExtension() && "invalid container for ivar!"); return CD->getClassInterface(); } @@ -1822,7 +1812,7 @@ ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation nameLoc, SourceLocation atStartLoc, ObjCProtocolDecl *PrevDecl) { - ObjCProtocolDecl *Result = + auto *Result = new (C, DC) ObjCProtocolDecl(C, DC, Id, nameLoc, atStartLoc, PrevDecl); Result->Data.setInt(!C.getLangOpts().Modules); return Result; @@ -1881,7 +1871,7 @@ void ObjCProtocolDecl::startDefinition() { allocateDefinitionData(); // Update all of the declarations with a pointer to the definition. - for (auto RD : redecls()) + for (auto *RD : redecls()) RD->Data = this->Data; } @@ -1923,7 +1913,7 @@ void ObjCProtocolDecl::collectInheritedProtocolProperties( StringRef ObjCProtocolDecl::getObjCRuntimeNameAsString() const { - if (ObjCRuntimeNameAttr *ObjCRTName = getAttr()) + if (const auto *ObjCRTName = getAttr()) return ObjCRTName->getMetadataName(); return getName(); @@ -1957,7 +1947,7 @@ ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC, ObjCTypeParamList *typeParamList, SourceLocation IvarLBraceLoc, SourceLocation IvarRBraceLoc) { - ObjCCategoryDecl *CatDecl = + auto *CatDecl = new (C, DC) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc, CategoryNameLoc, Id, IDecl, typeParamList, IvarLBraceLoc, IvarRBraceLoc); @@ -1995,11 +1985,10 @@ void ObjCCategoryDecl::setTypeParamList(ObjCTypeParamList *TPL) { if (!TPL) return; // Set the declaration context of each of the type parameters. - for (auto typeParam : *TypeParamList) + for (auto *typeParam : *TypeParamList) typeParam->setDeclContext(this); } - //===----------------------------------------------------------------------===// // ObjCCategoryImplDecl //===----------------------------------------------------------------------===// @@ -2044,13 +2033,11 @@ void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) { void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) { ASTContext &Ctx = getASTContext(); - if (ObjCImplementationDecl *ImplD - = dyn_cast_or_null(this)) { + if (auto *ImplD = dyn_cast_or_null(this)) { if (IFace) Ctx.setObjCImplementation(IFace, ImplD); - } else if (ObjCCategoryImplDecl *ImplD = - dyn_cast_or_null(this)) { + } else if (auto *ImplD = dyn_cast_or_null(this)) { if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier())) Ctx.setObjCImplementation(CD, ImplD); } @@ -2139,8 +2126,7 @@ void ObjCImplementationDecl::setIvarInitializers(ASTContext &C, unsigned numInitializers) { if (numInitializers > 0) { NumIvarInitializers = numInitializers; - CXXCtorInitializer **ivarInitializers = - new (C) CXXCtorInitializer*[NumIvarInitializers]; + auto **ivarInitializers = new (C) CXXCtorInitializer*[NumIvarInitializers]; memcpy(ivarInitializers, initializers, numInitializers * sizeof(CXXCtorInitializer*)); IvarInitializers = ivarInitializers; -- 2.7.4