[Analyzer] Use a reference in a range-based for

[Mordante]

Summary

This avoids unneeded copies when using a range-based for loops.

This avoids new warnings due to D68912 adds -Wrange-loop-analysis to -Wall.

clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp

public:
     virtual PathDiagnosticPieceRef
     VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
               PathSensitiveBugReport &BR) override;
 
     // FIXME: Scan the map once in the visitor's constructor and do a direct
     // lookup by region.
     bool isSymbolTracked(ProgramStateRef State, SymbolRef Sym) {
       RawPtrMapTy Map = State->get<RawPtrMap>();
-      for (const auto Entry : Map) {
+      for (const auto &Entry : Map) {
         if (Entry.second.contains(Sym))
           return true;
       }
       return false;
     }
   };
 
   InnerPointerChecker()
void InnerPointerChecker::checkPostCall(const CallEvent &Call,
   checkFunctionArguments(Call, State, C);
 }
 
 void InnerPointerChecker::checkDeadSymbols(SymbolReaper &SymReaper,
                                            CheckerContext &C) const {
   ProgramStateRef State = C.getState();
   PtrSet::Factory &F = State->getStateManager().get_context<PtrSet>();
   RawPtrMapTy RPM = State->get<RawPtrMap>();
-  for (const auto Entry : RPM) {
+  for (const auto &Entry : RPM) {
     if (!SymReaper.isLiveRegion(Entry.first)) {
       // Due to incomplete destructor support, some dead regions might
       // remain in the program state map. Clean them up.
       State = State->remove<RawPtrMap>(Entry.first);
     }
     if (const PtrSet *OldSet = State->get<RawPtrMap>(Entry.first)) {
       PtrSet CleanedUpSet = *OldSet;
       for (const auto Symbol : Entry.second) {

 namespace allocation_state {
 
 std::unique_ptr<BugReporterVisitor> getInnerPointerBRVisitor(SymbolRef Sym) {
   return std::make_unique<InnerPointerChecker::InnerPointerBRVisitor>(Sym);
 }
 
 const MemRegion *getContainerObjRegion(ProgramStateRef State, SymbolRef Sym) {
   RawPtrMapTy Map = State->get<RawPtrMap>();
-  for (const auto Entry : Map) {
+  for (const auto &Entry : Map) {
     if (Entry.second.contains(Sym)) {
       return Entry.first;
     }
   }
   return nullptr;
 }
 
 } // end namespace allocation_state

clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp

void IteratorChecker::checkPostStmt(const MaterializeTemporaryExpr *MTE,
   C.addTransition(State);
 }
 
 void IteratorChecker::checkLiveSymbols(ProgramStateRef State,
                                        SymbolReaper &SR) const {
   // Keep symbolic expressions of iterator positions, container begins and ends
   // alive
   auto RegionMap = State->get<IteratorRegionMap>();
-  for (const auto Reg : RegionMap) {
+  for (const auto &Reg : RegionMap) {
     const auto Offset = Reg.second.getOffset();
     for (auto i = Offset->symbol_begin(); i != Offset->symbol_end(); ++i)
       if (isa<SymbolData>(*i))
         SR.markLive(*i);
   }
 
   auto SymbolMap = State->get<IteratorSymbolMap>();
-  for (const auto Sym : SymbolMap) {
+  for (const auto &Sym : SymbolMap) {
     const auto Offset = Sym.second.getOffset();
     for (auto i = Offset->symbol_begin(); i != Offset->symbol_end(); ++i)
       if (isa<SymbolData>(*i))
         SR.markLive(*i);
   }
 
   auto ContMap = State->get<ContainerMap>();
-  for (const auto Cont : ContMap) {
+  for (const auto &Cont : ContMap) {
     const auto CData = Cont.second;
     if (CData.getBegin()) {
       SR.markLive(CData.getBegin());
       if(const auto *SIE = dyn_cast<SymIntExpr>(CData.getBegin()))
         SR.markLive(SIE->getLHS());
     }
     if (CData.getEnd()) {
       SR.markLive(CData.getEnd());
       if(const auto *SIE = dyn_cast<SymIntExpr>(CData.getEnd()))
         SR.markLive(SIE->getLHS());
     }
   }
 }
 
 void IteratorChecker::checkDeadSymbols(SymbolReaper &SR,
                                        CheckerContext &C) const {
   // Cleanup
   auto State = C.getState();
 
   auto RegionMap = State->get<IteratorRegionMap>();
-  for (const auto Reg : RegionMap) {
+  for (const auto &Reg : RegionMap) {
     if (!SR.isLiveRegion(Reg.first)) {
       // The region behind the `LazyCompoundVal` is often cleaned up before
       // the `LazyCompoundVal` itself. If there are iterator positions keyed
       // by these regions their cleanup must be deferred.
       if (!isBoundThroughLazyCompoundVal(State->getEnvironment(), Reg.first)) {
         State = State->remove<IteratorRegionMap>(Reg.first);
       }
     }
   }
 
   auto SymbolMap = State->get<IteratorSymbolMap>();
-  for (const auto Sym : SymbolMap) {
+  for (const auto &Sym : SymbolMap) {
     if (!SR.isLive(Sym.first)) {
       State = State->remove<IteratorSymbolMap>(Sym.first);
     }
   }
 
   auto ContMap = State->get<ContainerMap>();
-  for (const auto Cont : ContMap) {
+  for (const auto &Cont : ContMap) {
     if (!SR.isLiveRegion(Cont.first)) {
       // We must keep the container data while it has live iterators to be able
       // to compare them to the begin and the end of the container.
       if (!hasLiveIterators(State, Cont.first)) {
         State = State->remove<ContainerMap>(Cont.first);
       }
     }
   }
if (const auto CompSym = comparison.getAsSymbol()) {
     return assumeNoOverflow(NewState, cast<SymIntExpr>(CompSym)->getLHS(), 2);
   }
 
   return NewState;
 }
 
 bool hasLiveIterators(ProgramStateRef State, const MemRegion *Cont) {
   auto RegionMap = State->get<IteratorRegionMap>();
-  for (const auto Reg : RegionMap) {
+  for (const auto &Reg : RegionMap) {
     if (Reg.second.getContainer() == Cont)
       return true;
   }
 
   auto SymbolMap = State->get<IteratorSymbolMap>();
-  for (const auto Sym : SymbolMap) {
+  for (const auto &Sym : SymbolMap) {
     if (Sym.second.getContainer() == Cont)
       return true;
   }
 
   return false;
 }
 
 bool isBoundThroughLazyCompoundVal(const Environment &Env,
                                    const MemRegion *Reg) {
-  for (const auto Binding: Env) {
+  for (const auto &Binding : Env) {
     if (const auto LCVal = Binding.second.getAs<nonloc::LazyCompoundVal>()) {
       if (LCVal->getRegion() == Reg)
         return true;
     }
   }
 
   return false;
 }

 }
 
 template <typename Condition, typename Process>
 ProgramStateRef processIteratorPositions(ProgramStateRef State, Condition Cond,
                                          Process Proc) {
   auto &RegionMapFactory = State->get_context<IteratorRegionMap>();
   auto RegionMap = State->get<IteratorRegionMap>();
   bool Changed = false;
-  for (const auto Reg : RegionMap) {
+  for (const auto &Reg : RegionMap) {
     if (Cond(Reg.second)) {
       RegionMap = RegionMapFactory.add(RegionMap, Reg.first, Proc(Reg.second));
       Changed = true;
     }
   }
 
   if (Changed)
     State = State->set<IteratorRegionMap>(RegionMap);
 
   auto &SymbolMapFactory = State->get_context<IteratorSymbolMap>();
   auto SymbolMap = State->get<IteratorSymbolMap>();
   Changed = false;
-  for (const auto Sym : SymbolMap) {
+  for (const auto &Sym : SymbolMap) {
     if (Cond(Sym.second)) {
       SymbolMap = SymbolMapFactory.add(SymbolMap, Sym.first, Proc(Sym.second));
       Changed = true;
     }
   }
 
   if (Changed)
     State = State->set<IteratorSymbolMap>(SymbolMap);

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

NoStoreFuncVisitor::findRegionOfInterestInRecord(
 
   if (const auto *RDX = dyn_cast<CXXRecordDecl>(RD))
     if (!RDX->hasDefinition())
       return None;
 
   // Recursively examine the base classes.
   // Note that following base classes does not increase the recursion depth.
   if (const auto *RDX = dyn_cast<CXXRecordDecl>(RD))
-    for (const auto II : RDX->bases())
+    for (const auto &II : RDX->bases())
       if (const RecordDecl *RRD = II.getType()->getAsRecordDecl())
         if (Optional<RegionVector> Out =
                 findRegionOfInterestInRecord(RRD, State, R, Vec, depth))
           return Out;
 
   for (const FieldDecl *I : RD->fields()) {
     QualType FT = I->getType();
     const FieldRegion *FR = MmrMgr.getFieldRegion(I, cast<SubRegion>(R));