diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index 3bc748969065a..37b96e1ddf3ac 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -316,8 +316,8 @@ void Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg, UnparsedDefaultArgInstantiationsMap::iterator InstPos = UnparsedDefaultArgInstantiations.find(Param); if (InstPos != UnparsedDefaultArgInstantiations.end()) { - for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I) - InstPos->second[I]->setUninstantiatedDefaultArg(Arg); + for (auto &Instantiation : InstPos->second) + Instantiation->setUninstantiatedDefaultArg(Arg); // We're done tracking this parameter's instantiations. UnparsedDefaultArgInstantiations.erase(InstPos); @@ -2547,8 +2547,8 @@ static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, diag::ext_constexpr_function_never_constant_expr) << isa(Dcl) << Dcl->isConsteval() << Dcl->getNameInfo().getSourceRange(); - for (size_t I = 0, N = Diags.size(); I != N; ++I) - SemaRef.Diag(Diags[I].first, Diags[I].second); + for (const auto &Diag : Diags) + SemaRef.Diag(Diag.first, Diag.second); // Don't return false here: we allow this for compatibility in // system headers. } @@ -3211,17 +3211,15 @@ Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) { std::string PathDisplayStr; std::set DisplayedPaths; - for (CXXBasePaths::paths_iterator Path = Paths.begin(); - Path != Paths.end(); ++Path) { - if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) { + for (const CXXBasePath &Path : Paths) { + if (DisplayedPaths.insert(Path.back().SubobjectNumber).second) { // We haven't displayed a path to this particular base // class subobject yet. PathDisplayStr += "\n "; PathDisplayStr += QualType(Context.getCanonicalTagType(Paths.getOrigin())) .getAsString(); - for (CXXBasePath::const_iterator Element = Path->begin(); - Element != Path->end(); ++Element) - PathDisplayStr += " -> " + Element->Base->getType().getAsString(); + for (const CXXBasePathElement &Element : Path) + PathDisplayStr += " -> " + Element.Base->getType().getAsString(); } } @@ -4260,10 +4258,9 @@ static bool FindBaseInitializer(Sema &SemaRef, if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(), SemaRef.Context.getCanonicalTagType(ClassDecl), BaseType, Paths)) { - for (CXXBasePaths::paths_iterator Path = Paths.begin(); - Path != Paths.end(); ++Path) { - if (Path->back().Base->isVirtual()) { - VirtualBaseSpec = Path->back().Base; + for (const CXXBasePath &Path : Paths) { + if (Path.back().Base->isVirtual()) { + VirtualBaseSpec = Path.back().Base; break; } } @@ -5468,9 +5465,7 @@ bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, bool HadError = false; - for (unsigned i = 0; i < Initializers.size(); i++) { - CXXCtorInitializer *Member = Initializers[i]; - + for (CXXCtorInitializer *Member : Initializers) { if (Member->isBaseInitializer()) Info.AllBaseFields[Member->getBaseClass()->getAsCanonical()] = Member; @@ -5675,8 +5670,7 @@ static void DiagnoseBaseOrMemInitializerOrder( // Don't check initializers order unless the warning is enabled at the // location of at least one initializer. bool ShouldCheckOrder = false; - for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) { - CXXCtorInitializer *Init = Inits[InitIndex]; + for (CXXCtorInitializer *Init : Inits) { if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order, Init->getSourceLocation())) { ShouldCheckOrder = true; @@ -6045,31 +6039,25 @@ void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) { // more than once. llvm::SmallPtrSet SeenPureMethods; - for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), - MEnd = FinalOverriders.end(); - M != MEnd; - ++M) { - for (OverridingMethods::iterator SO = M->second.begin(), - SOEnd = M->second.end(); - SO != SOEnd; ++SO) { + for (const auto &M : FinalOverriders) { + for (const auto &SO : M.second) { // C++ [class.abstract]p4: // A class is abstract if it contains or inherits at least one // pure virtual function for which the final overrider is pure // virtual. - // - if (SO->second.size() != 1) + if (SO.second.size() != 1) continue; + const CXXMethodDecl *Method = SO.second.front().Method; - if (!SO->second.front().Method->isPureVirtual()) + if (!Method->isPureVirtual()) continue; - if (!SeenPureMethods.insert(SO->second.front().Method).second) + if (!SeenPureMethods.insert(Method).second) continue; - Diag(SO->second.front().Method->getLocation(), - diag::note_pure_virtual_function) - << SO->second.front().Method->getDeclName() << RD->getDeclName(); + Diag(Method->getLocation(), diag::note_pure_virtual_function) + << Method->getDeclName() << RD->getDeclName(); } } @@ -7012,18 +7000,16 @@ void Sema::CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record) { // C++ [class.mem]p14: // In addition, if class T has a user-declared constructor (12.1), every // non-static data member of class T shall have a name different from T. - DeclContext::lookup_result R = Record->lookup(Record->getDeclName()); - for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; - ++I) { - NamedDecl *D = (*I)->getUnderlyingDecl(); + for (const NamedDecl *Element : Record->lookup(Record->getDeclName())) { + const NamedDecl *D = Element->getUnderlyingDecl(); // Invalid IndirectFieldDecls have already been diagnosed with // err_anonymous_record_member_redecl in // SemaDecl.cpp:CheckAnonMemberRedeclaration. if (((isa(D) || isa(D)) && Record->hasUserDeclaredConstructor()) || (isa(D) && !D->isInvalidDecl())) { - Diag((*I)->getLocation(), diag::err_member_name_of_class) - << D->getDeclName(); + Diag(Element->getLocation(), diag::err_member_name_of_class) + << D->getDeclName(); break; } } @@ -10552,10 +10538,8 @@ void Sema::FindHiddenVirtualMethods(CXXMethodDecl *MD, // Keep the base methods that were overridden or introduced in the subclass // by 'using' in a set. A base method not in this set is hidden. CXXRecordDecl *DC = MD->getParent(); - DeclContext::lookup_result R = DC->lookup(MD->getDeclName()); - for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) { - NamedDecl *ND = *I; - if (UsingShadowDecl *shad = dyn_cast(*I)) + for (NamedDecl *ND : DC->lookup(MD->getDeclName())) { + if (UsingShadowDecl *shad = dyn_cast(ND)) ND = shad->getTargetDecl(); if (CXXMethodDecl *MD = dyn_cast(ND)) AddMostOverridenMethods(MD, FHVM.OverridenAndUsingBaseMethods); @@ -10567,8 +10551,7 @@ void Sema::FindHiddenVirtualMethods(CXXMethodDecl *MD, void Sema::NoteHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl &OverloadedMethods) { - for (unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) { - CXXMethodDecl *overloadedMD = OverloadedMethods[i]; + for (const CXXMethodDecl *overloadedMD : OverloadedMethods) { PartialDiagnostic PD = PDiag( diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD; HandleFunctionTypeMismatch(PD, MD->getType(), overloadedMD->getType()); @@ -12787,9 +12770,8 @@ bool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, // should redeclare it. NamedDecl *NonTag = nullptr, *Tag = nullptr; bool FoundEquivalentDecl = false; - for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); - I != E; ++I) { - NamedDecl *D = (*I)->getUnderlyingDecl(); + for (NamedDecl *Element : Previous) { + NamedDecl *D = Element->getUnderlyingDecl(); // We can have UsingDecls in our Previous results because we use the same // LookupResult for checking whether the UsingDecl itself is a valid // redeclaration. @@ -12810,7 +12792,7 @@ bool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, } if (IsEquivalentForUsingDecl(Context, D, Target)) { - if (UsingShadowDecl *Shadow = dyn_cast(*I)) + if (UsingShadowDecl *Shadow = dyn_cast(Element)) PrevShadow = Shadow; FoundEquivalentDecl = true; } else if (isEquivalentInternalLinkageDeclaration(D, Target)) { @@ -13298,8 +13280,8 @@ NamedDecl *Sema::BuildUsingDeclaration( if (!R.getAsSingle() && !R.getAsSingle()) { Diag(IdentLoc, diag::err_using_typename_non_type); - for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) - Diag((*I)->getUnderlyingDecl()->getLocation(), + for (const NamedDecl *D : R) + Diag(D->getUnderlyingDecl()->getLocation(), diag::note_using_decl_target); return BuildInvalid(); } @@ -13337,10 +13319,10 @@ NamedDecl *Sema::BuildUsingDeclaration( return UD; } - for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { + for (NamedDecl *D : R) { UsingShadowDecl *PrevDecl = nullptr; - if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl)) - BuildUsingShadowDecl(S, UD, *I, PrevDecl); + if (!CheckUsingShadowDecl(UD, D, Previous, PrevDecl)) + BuildUsingShadowDecl(S, UD, D, PrevDecl); } return UD; @@ -13476,23 +13458,22 @@ bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc, } NestedNameSpecifier CNNS = Qual.getCanonical(); - for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) { - NamedDecl *D = *I; - + for (const NamedDecl *D : Prev) { bool DTypename; NestedNameSpecifier DQual = std::nullopt; - if (UsingDecl *UD = dyn_cast(D)) { + if (const UsingDecl *UD = dyn_cast(D)) { DTypename = UD->hasTypename(); DQual = UD->getQualifier(); - } else if (UnresolvedUsingValueDecl *UD - = dyn_cast(D)) { + } else if (const UnresolvedUsingValueDecl *UD = + dyn_cast(D)) { DTypename = false; DQual = UD->getQualifier(); - } else if (UnresolvedUsingTypenameDecl *UD - = dyn_cast(D)) { + } else if (const UnresolvedUsingTypenameDecl *UD = + dyn_cast(D)) { DTypename = true; DQual = UD->getQualifier(); - } else continue; + } else + continue; // using decls differ if one says 'typename' and the other doesn't. // FIXME: non-dependent using decls? @@ -16378,8 +16359,8 @@ void Sema::FinalizeVarWithDestructor(VarDecl *VD, CXXRecordDecl *ClassDecl) { HasConstantInit) { Diag(VD->getLocation(), diag::err_constexpr_var_requires_const_destruction) << VD; - for (unsigned I = 0, N = Notes.size(); I != N; ++I) - Diag(Notes[I].first, Notes[I].second); + for (const PartialDiagnosticAt &Note : Notes) + Diag(Note.first, Note.second); } } @@ -17658,21 +17639,20 @@ void Sema::DiagnoseStaticAssertDetails(const Expr *E) { Expr::EvalResult Result; SmallString<12> ValueString; bool Print; - } DiagSide[2] = {{LHS, Expr::EvalResult(), {}, false}, - {RHS, Expr::EvalResult(), {}, false}}; - for (unsigned I = 0; I < 2; I++) { - const Expr *Side = DiagSide[I].Cond; + } DiagSides[2] = {{LHS, Expr::EvalResult(), {}, false}, + {RHS, Expr::EvalResult(), {}, false}}; + for (auto &DiagSide : DiagSides) { + const Expr *Side = DiagSide.Cond; - Side->EvaluateAsRValue(DiagSide[I].Result, Context, true); + Side->EvaluateAsRValue(DiagSide.Result, Context, true); - DiagSide[I].Print = - ConvertAPValueToString(DiagSide[I].Result.Val, Side->getType(), - DiagSide[I].ValueString, Context); + DiagSide.Print = ConvertAPValueToString( + DiagSide.Result.Val, Side->getType(), DiagSide.ValueString, Context); } - if (DiagSide[0].Print && DiagSide[1].Print) { + if (DiagSides[0].Print && DiagSides[1].Print) { Diag(Op->getExprLoc(), diag::note_expr_evaluates_to) - << DiagSide[0].ValueString << Op->getOpcodeStr() - << DiagSide[1].ValueString << Op->getSourceRange(); + << DiagSides[0].ValueString << Op->getOpcodeStr() + << DiagSides[1].ValueString << Op->getSourceRange(); } } else { DiagnoseTypeTraitDetails(E); @@ -17969,13 +17949,9 @@ DeclResult Sema::ActOnTemplatedFriendTag( if (Invalid) return true; - bool isAllExplicitSpecializations = true; - for (unsigned I = TempParamLists.size(); I-- > 0; ) { - if (TempParamLists[I]->size()) { - isAllExplicitSpecializations = false; - break; - } - } + const bool isAllExplicitSpecializations = std::all_of( + TempParamLists.begin(), TempParamLists.end(), + [](const TemplateParameterList *List) { return List->size() == 0; }); // FIXME: don't ignore attributes. @@ -18973,18 +18949,18 @@ void Sema::LoadExternalVTableUses() { SmallVector VTables; ExternalSource->ReadUsedVTables(VTables); SmallVector NewUses; - for (unsigned I = 0, N = VTables.size(); I != N; ++I) { - llvm::DenseMap::iterator Pos - = VTablesUsed.find(VTables[I].Record); + for (const ExternalVTableUse &VTable : VTables) { + llvm::DenseMap::iterator Pos = + VTablesUsed.find(VTable.Record); // Even if a definition wasn't required before, it may be required now. if (Pos != VTablesUsed.end()) { - if (!Pos->second && VTables[I].DefinitionRequired) + if (!Pos->second && VTable.DefinitionRequired) Pos->second = true; continue; } - VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired; - NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location)); + VTablesUsed[VTable.Record] = VTable.DefinitionRequired; + NewUses.push_back(VTableUse(VTable.Record, VTable.Location)); } VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end()); @@ -19159,14 +19135,10 @@ void Sema::MarkVirtualMembersReferenced(SourceLocation Loc, // Mark all functions which will appear in RD's vtable as used. CXXFinalOverriderMap FinalOverriders; RD->getFinalOverriders(FinalOverriders); - for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(), - E = FinalOverriders.end(); - I != E; ++I) { - for (OverridingMethods::const_iterator OI = I->second.begin(), - OE = I->second.end(); - OI != OE; ++OI) { - assert(OI->second.size() > 0 && "no final overrider"); - CXXMethodDecl *Overrider = OI->second.front().Method; + for (const auto &FinalOverrider : FinalOverriders) { + for (const auto &OverridingMethod : FinalOverrider.second) { + assert(OverridingMethod.second.size() > 0 && "no final overrider"); + CXXMethodDecl *Overrider = OverridingMethod.second.front().Method; // C++ [basic.def.odr]p2: // [...] A virtual member function is used if it is not pure. [...] @@ -19262,8 +19234,8 @@ void Sema::CheckDelegatingCtorCycles() { I != E; ++I) DelegatingCycleHelper(*I, Valid, Invalid, Current, *this); - for (auto CI = Invalid.begin(), CE = Invalid.end(); CI != CE; ++CI) - (*CI)->setInvalidDecl(); + for (CXXConstructorDecl *CI : Invalid) + CI->setInvalidDecl(); } namespace { @@ -19394,8 +19366,8 @@ bool Sema::checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method) { if (Arg && !Finder.TraverseStmt(Arg)) return true; - for (unsigned I = 0, N = Args.size(); I != N; ++I) { - if (!Finder.TraverseStmt(Args[I])) + for (Expr *A : Args) { + if (!Finder.TraverseStmt(A)) return true; } }