[analyzer][NFC] Uplift checkers after D126801

[martong]

I think we should avoid auto when using State->get<> because the type is not immediate for the reader. (Unlike in a cast<T>.)

clang/lib/StaticAnalyzer/Checkers/ErrnoModeling.cpp

198

clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp

108

I'd rather keep the type here.

[steakhal]

• replace auto

[martong]

LGTM

clang/lib/StaticAnalyzer/Checkers/ErrnoModeling.cpp

CallDescriptionSet ErrnoLocationCalls{{"__errno_location", 0, 0},
                                         {"_errno", 0, 0},
                                         {"__error", 0, 0}};
 };
 
 } // namespace
 
 /// Store a MemRegion that contains the 'errno' integer value.
 /// The value is null if the 'errno' value was not recognized in the AST.
-REGISTER_TRAIT_WITH_PROGRAMSTATE(ErrnoRegion, const void *)
-
-/// An internal function accessing the errno region.
-/// Returns null if there isn't any associated memory region.
-static const MemRegion *getErrnoRegion(ProgramStateRef State) {
-  return reinterpret_cast<const MemRegion *>(State->get<ErrnoRegion>());
-}
+REGISTER_TRAIT_WITH_PROGRAMSTATE(ErrnoRegion, const MemRegion *)
 
 /// Search for a variable called "errno" in the AST.
 /// Return nullptr if not found.
 static const VarDecl *getErrnoVar(ASTContext &ACtx) {
   IdentifierInfo &II = ACtx.Idents.get(ErrnoVarName);
   auto LookupRes = ACtx.getTranslationUnitDecl()->lookup(&II);
   auto Found = llvm::find_if(LookupRes, [&ACtx](const Decl *D) {
     if (auto *VD = dyn_cast<VarDecl>(D))

 }
 
 bool ErrnoModeling::evalCall(const CallEvent &Call, CheckerContext &C) const {
   // Return location of "errno" at a call to an "errno address returning"
   // function.
   if (ErrnoLocationCalls.contains(Call)) {
     ProgramStateRef State = C.getState();
 
-    const MemRegion *ErrnoR = getErrnoRegion(State);
+    const MemRegion *ErrnoR = State->get<ErrnoRegion>();
     if (!ErrnoR)
       return false;
 
     State = State->BindExpr(Call.getOriginExpr(), C.getLocationContext(),
                             loc::MemRegionVal{ErrnoR});
     C.addTransition(State);
     return true;
   }
 
   return false;
 }
 
 void ErrnoModeling::checkLiveSymbols(ProgramStateRef State,
                                      SymbolReaper &SR) const {
   // The special errno region should never garbage collected.
-  if (const auto *ErrnoR = getErrnoRegion(State))
+  if (const MemRegion *ErrnoR = State->get<ErrnoRegion>())
     SR.markLive(ErrnoR);
 }
 
 namespace clang {
 namespace ento {
 namespace errno_modeling {
 
 Optional<SVal> getErrnoValue(ProgramStateRef State) {
-  const MemRegion *ErrnoR = getErrnoRegion(State);
+  const MemRegion *ErrnoR = State->get<ErrnoRegion>();
   if (!ErrnoR)
     return {};
   QualType IntTy = State->getAnalysisManager().getASTContext().IntTy;
   return State->getSVal(ErrnoR, IntTy);
 }
 
 ProgramStateRef setErrnoValue(ProgramStateRef State,
                               const LocationContext *LCtx, SVal Value) {
-  const MemRegion *ErrnoR = getErrnoRegion(State);
+  const MemRegion *ErrnoR = State->get<ErrnoRegion>();
   if (!ErrnoR)
     return State;
   return State->bindLoc(loc::MemRegionVal{ErrnoR}, Value, LCtx);
 }
 
 ProgramStateRef setErrnoValue(ProgramStateRef State, CheckerContext &C,
                               uint64_t Value) {
-  const MemRegion *ErrnoR = getErrnoRegion(State);
+  const MemRegion *ErrnoR = State->get<ErrnoRegion>();
   if (!ErrnoR)
     return State;
   return State->bindLoc(
       loc::MemRegionVal{ErrnoR},
       C.getSValBuilder().makeIntVal(Value, C.getASTContext().IntTy),
       C.getLocationContext());
 }
 

clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp

 
 REGISTER_MAP_WITH_PROGRAMSTATE(SelfFlag, SymbolRef, unsigned)
 REGISTER_TRAIT_WITH_PROGRAMSTATE(CalledInit, bool)
 
 /// A call receiving a reference to 'self' invalidates the object that
 /// 'self' contains. This keeps the "self flags" assigned to the 'self'
 /// object before the call so we can assign them to the new object that 'self'
 /// points to after the call.
-REGISTER_TRAIT_WITH_PROGRAMSTATE(PreCallSelfFlags, unsigned)
+REGISTER_TRAIT_WITH_PROGRAMSTATE(PreCallSelfFlags, SelfFlagEnum)
 
 static SelfFlagEnum getSelfFlags(SVal val, ProgramStateRef state) {
   if (SymbolRef sym = val.getAsSymbol())
     if (const unsigned *attachedFlags = state->get<SelfFlag>(sym))
       return (SelfFlagEnum)*attachedFlags;
   return SelfFlag_None;
 }
 
 static SelfFlagEnum getSelfFlags(SVal val, CheckerContext &C) {
   return getSelfFlags(val, C.getState());
 }
 
void ObjCSelfInitChecker::checkPreCall(const CallEvent &CE,
   // If we passed 'self' as and argument to the call, record it in the state
   // to be propagated after the call.
   // Note, we could have just given up, but try to be more optimistic here and
   // assume that the functions are going to continue initialization or will not
   // modify self.
   for (unsigned i = 0; i < NumArgs; ++i) {
     SVal argV = CE.getArgSVal(i);
     if (isSelfVar(argV, C)) {
-      unsigned selfFlags = getSelfFlags(state->getSVal(argV.castAs<Loc>()), C);
+      SelfFlagEnum selfFlags =
+          getSelfFlags(state->getSVal(argV.castAs<Loc>()), C);
       C.addTransition(state->set<PreCallSelfFlags>(selfFlags));
       return;
     } else if (hasSelfFlag(argV, SelfFlag_Self, C)) {
-      unsigned selfFlags = getSelfFlags(argV, C);
+      SelfFlagEnum selfFlags = getSelfFlags(argV, C);
       C.addTransition(state->set<PreCallSelfFlags>(selfFlags));
       return;
     }
   }
 }
 
 void ObjCSelfInitChecker::checkPostCall(const CallEvent &CE,
                                         CheckerContext &C) const {