[analyzer] DynamicTypeInfo: Simplify the API

[Charusso]

Summary

DynamicTypeInfo -> Optional<DynamicTypeInfo>,
which removes the method bool isValid().

[NoQ]

I actually like the idea, it makes it consistent with other maps. But you'll need to clean up memory management here. Given that you can't modify the state in getDynamicTypeInfo(), i guess you'll have to resort to smart pointers.

clang/lib/StaticAnalyzer/Core/DynamicType.cpp

49–56

Do i have to do a delete manually every time i call this function?

93

Who is responsible for deallocating this memory?

[Charusso]

• No comment.

[Charusso]

Sorry, I was sure it is working as expected.

clang/lib/StaticAnalyzer/Core/DynamicType.cpp

49–56

Well, from now you do not.

[NoQ]

Yup, optional sounds perfect.

clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicType.h

 #include "llvm/ADT/ImmutableMap.h"
 #include "llvm/ADT/Optional.h"
 #include <utility>
 
 namespace clang {
 namespace ento {
 
 /// Get dynamic type information for the region \p MR.
-DynamicTypeInfo getDynamicTypeInfo(ProgramStateRef State, const MemRegion *MR);
+Optional<DynamicTypeInfo> getDynamicTypeInfo(ProgramStateRef State,
+                                             const MemRegion *MR);
 
-/// Get raw dynamic type information for the region \p MR.
-const DynamicTypeInfo *getRawDynamicTypeInfo(ProgramStateRef State,
+/// Get the stored dynamic type information for the region \p MR.
+Optional<DynamicTypeInfo> getStoredDynamicTypeInfo(ProgramStateRef State,
                                                    const MemRegion *MR);
 
 /// Get dynamic cast information from \p CastFromTy to \p CastToTy of \p MR.
-const DynamicCastInfo *getDynamicCastInfo(ProgramStateRef State,
+Optional<DynamicCastInfo> getDynamicCastInfo(ProgramStateRef State,
                                              const MemRegion *MR,
                                              QualType CastFromTy,
                                              QualType CastToTy);
 
 /// Set dynamic type information of the region; return the new state.
 ProgramStateRef setDynamicTypeInfo(ProgramStateRef State, const MemRegion *MR,
                                    DynamicTypeInfo NewTy);
 
 /// Set dynamic type information of the region; return the new state.
 ProgramStateRef setDynamicTypeInfo(ProgramStateRef State, const MemRegion *MR,
                                    QualType NewTy, bool CanBeSubClassed = true);

clang/lib/StaticAnalyzer/Checkers/CastValueChecker.cpp

void evalGetAs(const CallEvent &Call, DefinedOrUnknownSVal DV,
                  CheckerContext &C) const;
   void evalIsa(const CallEvent &Call, DefinedOrUnknownSVal DV,
                CheckerContext &C) const;
   void evalIsaAndNonNull(const CallEvent &Call, DefinedOrUnknownSVal DV,
                          CheckerContext &C) const;
 };
 } // namespace
 
-static bool isInfeasibleCast(const DynamicCastInfo *CastInfo,
+static bool isInfeasibleCast(Optional<DynamicCastInfo> CastInfo,
                              bool CastSucceeds) {
   if (!CastInfo)
     return false;
 
   return CastSucceeds ? CastInfo->fails() : CastInfo->succeeds();
 }
 
 static const NoteTag *getNoteTag(CheckerContext &C,
-                                 const DynamicCastInfo *CastInfo,
+                                 Optional<DynamicCastInfo> CastInfo,
                                  QualType CastToTy, const Expr *Object,
                                  bool CastSucceeds, bool IsKnownCast) {
   std::string CastToName =
       CastInfo ? CastInfo->to()->getPointeeCXXRecordDecl()->getNameAsString()
                : CastToTy->getPointeeCXXRecordDecl()->getNameAsString();
   Object = Object->IgnoreParenImpCasts();
 
   return C.getNoteTag(
if (CastToTy->isPointerType()) {
       if (!CastFromTy->isReferenceType())
         return;
 
       CastFromTy = alignReferenceTypes(CastFromTy, CastToTy, C.getASTContext());
     }
   }
 
   const MemRegion *MR = DV.getAsRegion();
-  const DynamicCastInfo *CastInfo =
+  Optional<DynamicCastInfo> CastInfo =
       getDynamicCastInfo(State, MR, CastFromTy, CastToTy);
 
   // We assume that every checked cast succeeds.
   bool CastSucceeds = IsCheckedCast || CastFromTy == CastToTy;
   if (!CastSucceeds) {
     if (CastInfo)
       CastSucceeds = IsNonNullReturn && CastInfo->succeeds();
     else
static void addInstanceOfTransition(const CallEvent &Call,
   if (CastFromTy->isPointerType())
     CastToTy = C.getASTContext().getPointerType(CastToTy);
   else if (CastFromTy->isReferenceType())
     CastToTy = alignReferenceTypes(CastToTy, CastFromTy, C.getASTContext());
   else
     return;
 
   const MemRegion *MR = DV.getAsRegion();
-  const DynamicCastInfo *CastInfo =
+  Optional<DynamicCastInfo> CastInfo =
       getDynamicCastInfo(State, MR, CastFromTy, CastToTy);
 
   bool CastSucceeds;
   if (CastInfo)
     CastSucceeds = IsInstanceOf && CastInfo->succeeds();
   else
     CastSucceeds = IsInstanceOf || CastFromTy == CastToTy;
 

clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp

void DynamicTypeChecker::reportTypeError(QualType DynamicType,
   C.emitReport(std::move(R));
 }
 
 PathDiagnosticPieceRef DynamicTypeChecker::DynamicTypeBugVisitor::VisitNode(
     const ExplodedNode *N, BugReporterContext &BRC, PathSensitiveBugReport &) {
   ProgramStateRef State = N->getState();
   ProgramStateRef StatePrev = N->getFirstPred()->getState();
 
-  DynamicTypeInfo TrackedType = getDynamicTypeInfo(State, Reg);
-  DynamicTypeInfo TrackedTypePrev = getDynamicTypeInfo(StatePrev, Reg);
-  if (!TrackedType.isValid())
+  Optional<DynamicTypeInfo> TrackedType = getDynamicTypeInfo(State, Reg);
+  Optional<DynamicTypeInfo> TrackedTypePrev =
+      getDynamicTypeInfo(StatePrev, Reg);
+  if (!TrackedType)
     return nullptr;
 
-  if (TrackedTypePrev.isValid() &&
-      TrackedTypePrev.getType() == TrackedType.getType())
+  if (TrackedTypePrev && TrackedTypePrev->getType() == TrackedType->getType())
     return nullptr;
 
   // Retrieve the associated statement.
   const Stmt *S = N->getStmtForDiagnostics();
   if (!S)
     return nullptr;
 
   const LangOptions &LangOpts = BRC.getASTContext().getLangOpts();
 
   SmallString<256> Buf;
   llvm::raw_svector_ostream OS(Buf);
   OS << "Type '";
-  QualType::print(TrackedType.getType().getTypePtr(), Qualifiers(), OS,
+  QualType::print(TrackedType->getType().getTypePtr(), Qualifiers(), OS,
                   LangOpts, llvm::Twine());
   OS << "' is inferred from ";
 
   if (const auto *ExplicitCast = dyn_cast<ExplicitCastExpr>(S)) {
     OS << "explicit cast (from '";
     QualType::print(ExplicitCast->getSubExpr()->getType().getTypePtr(),
                     Qualifiers(), OS, LangOpts, llvm::Twine());
     OS << "' to '";
void DynamicTypeChecker::checkPostStmt(const ImplicitCastExpr *CE,
   if (CE->getCastKind() != CK_BitCast)
     return;
 
   const MemRegion *Region = C.getSVal(CE).getAsRegion();
   if (!Region)
     return;
 
   ProgramStateRef State = C.getState();
-  DynamicTypeInfo DynTypeInfo = getDynamicTypeInfo(State, Region);
+  Optional<DynamicTypeInfo> DynTypeInfo = getDynamicTypeInfo(State, Region);
 
-  if (!DynTypeInfo.isValid())
+  if (!DynTypeInfo)
     return;
 
-  QualType DynType = DynTypeInfo.getType();
+  QualType DynType = DynTypeInfo->getType();
   QualType StaticType = CE->getType();
 
   const auto *DynObjCType = DynType->getAs<ObjCObjectPointerType>();
   const auto *StaticObjCType = StaticType->getAs<ObjCObjectPointerType>();
 
   if (!DynObjCType || !StaticObjCType)
     return;
 
   if (!hasDefinition(DynObjCType) || !hasDefinition(StaticObjCType))
     return;
 
   ASTContext &ASTCtxt = C.getASTContext();
 
   // Strip kindeofness to correctly detect subtyping relationships.
   DynObjCType = DynObjCType->stripObjCKindOfTypeAndQuals(ASTCtxt);
   StaticObjCType = StaticObjCType->stripObjCKindOfTypeAndQuals(ASTCtxt);
 
   // Specialized objects are handled by the generics checker.
   if (StaticObjCType->isSpecialized())
     return;
 
   if (ASTCtxt.canAssignObjCInterfaces(StaticObjCType, DynObjCType))
     return;
 
-  if (DynTypeInfo.canBeASubClass() &&
+  if (DynTypeInfo->canBeASubClass() &&
       ASTCtxt.canAssignObjCInterfaces(DynObjCType, StaticObjCType))
     return;
 
   reportTypeError(DynType, StaticType, Region, CE, C);
 }
 
 void ento::registerDynamicTypeChecker(CheckerManager &mgr) {
   mgr.registerChecker<DynamicTypeChecker>();
 }
 
 bool ento::shouldRegisterDynamicTypeChecker(const LangOptions &LO) {
   return true;
 }

clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

if (D && D->hasRelatedResultType()) {
         break;
       }
       case OMF_init: {
         // Assume, the result of the init method has the same dynamic type as
         // the receiver and propagate the dynamic type info.
         const MemRegion *RecReg = Msg->getReceiverSVal().getAsRegion();
         if (!RecReg)
           return;
-        DynamicTypeInfo RecDynType = getDynamicTypeInfo(State, RecReg);
-        C.addTransition(setDynamicTypeInfo(State, RetReg, RecDynType));
+        if (Optional<DynamicTypeInfo> RecDynType =
+                getDynamicTypeInfo(State, RecReg))
+          C.addTransition(setDynamicTypeInfo(State, RetReg, *RecDynType));
         break;
       }
       }
     }
     return;
   }
 
   if (const CXXConstructorCall *Ctor = dyn_cast<CXXConstructorCall>(&Call)) {
DynamicTypePropagation::getBetterObjCType(const Expr *CastE,
   const MemRegion *ToR = C.getSVal(CastE).getAsRegion();
   assert(ToR);
 
   // Get the old and new types.
   const ObjCObjectPointerType *NewTy =
       CastE->getType()->getAs<ObjCObjectPointerType>();
   if (!NewTy)
     return nullptr;
-  QualType OldDTy = getDynamicTypeInfo(C.getState(), ToR).getType();
-  if (OldDTy.isNull()) {
+  Optional<DynamicTypeInfo> OldDTy = getDynamicTypeInfo(C.getState(), ToR);
+  if (!OldDTy) {
     return NewTy;
   }
   const ObjCObjectPointerType *OldTy =
-    OldDTy->getAs<ObjCObjectPointerType>();
+      OldDTy->getType()->getAs<ObjCObjectPointerType>();
   if (!OldTy)
     return nullptr;
 
   // Id the old type is 'id', the new one is more precise.
   if (OldTy->isObjCIdType() && !NewTy->isObjCIdType())
     return NewTy;
 
   // Return new if it's a subclass of old.
void DynamicTypePropagation::checkPostObjCMessage(const ObjCMethodCall &M,
   if (ResultType.isNull())
     return;
 
   const MemRegion *RetRegion = M.getReturnValue().getAsRegion();
   ExplodedNode *Pred = C.getPredecessor();
   // When there is an entry available for the return symbol in DynamicTypeMap,
   // the call was inlined, and the information in the DynamicTypeMap is should
   // be precise.
-  if (RetRegion && !getRawDynamicTypeInfo(State, RetRegion)) {
+  if (RetRegion && !getStoredDynamicTypeInfo(State, RetRegion)) {
     // TODO: we have duplicated information in DynamicTypeMap and
     // MostSpecializedTypeArgsMap. We should only store anything in the later if
     // the stored data differs from the one stored in the former.
     State = setDynamicTypeInfo(State, RetRegion, ResultType,
                                /*CanBeSubClassed=*/true);
     Pred = C.addTransition(State);
   }
 

clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp

for (const auto *Method : CRD->methods()) {
     }
   }
   return false;
 }
 
 const CXXRecordDecl *getCXXRecordDecl(ProgramStateRef State,
                                       const MemRegion *Reg) {
   auto TI = getDynamicTypeInfo(State, Reg);
-  if (!TI.isValid())
+  if (!TI)
     return nullptr;
 
-  auto Type = TI.getType();
+  auto Type = TI->getType();
   if (const auto *RefT = Type->getAs<ReferenceType>()) {
     Type = RefT->getPointeeType();
   }
 
   return Type->getUnqualifiedDesugaredType()->getAsCXXRecordDecl();
 }
 
 SymbolRef getContainerBegin(ProgramStateRef State, const MemRegion *Cont) {

clang/lib/StaticAnalyzer/Core/CallEvent.cpp

if (!MD->isVirtual())
     return AnyFunctionCall::getRuntimeDefinition();
 
   // Do we know the implicit 'this' object being called?
   const MemRegion *R = getCXXThisVal().getAsRegion();
   if (!R)
     return {};
 
   // Do we know anything about the type of 'this'?
-  DynamicTypeInfo DynType = getDynamicTypeInfo(getState(), R);
-  if (!DynType.isValid())
+  Optional<DynamicTypeInfo> DynType = getDynamicTypeInfo(getState(), R);
+  if (!DynType)
     return {};
 
   // Is the type a C++ class? (This is mostly a defensive check.)
-  QualType RegionType = DynType.getType()->getPointeeType();
+  QualType RegionType = DynType->getType()->getPointeeType();
   assert(!RegionType.isNull() && "DynamicTypeInfo should always be a pointer.");
 
   const CXXRecordDecl *RD = RegionType->getAsCXXRecordDecl();
   if (!RD || !RD->hasDefinition())
     return {};
 
   // Find the decl for this method in that class.
   const CXXMethodDecl *Result = MD->getCorrespondingMethodInClass(RD, true);
if (!Result) {
     //assert(!MD->getParent()->isDerivedFrom(RD) && "Bad DynamicTypeInfo");
 
     return {};
   }
 
   // Does the decl that we found have an implementation?
   const FunctionDecl *Definition;
   if (!Result->hasBody(Definition)) {
-    if (!DynType.canBeASubClass())
+    if (!DynType->canBeASubClass())
       return AnyFunctionCall::getRuntimeDefinition();
     return {};
   }
 
   // We found a definition. If we're not sure that this devirtualization is
   // actually what will happen at runtime, make sure to provide the region so
   // that ExprEngine can decide what to do with it.
-  if (DynType.canBeASubClass())
+  if (DynType->canBeASubClass())
     return RuntimeDefinition(Definition, R->StripCasts());
   return RuntimeDefinition(Definition, /*DispatchRegion=*/nullptr);
 }
 
 void CXXInstanceCall::getInitialStackFrameContents(
                                             const StackFrameContext *CalleeCtx,
                                             BindingsTy &Bindings) const {
   AnyFunctionCall::getInitialStackFrameContents(CalleeCtx, Bindings);
if (!SupersType.isNull()) {
       // Super always means the type of immediate predecessor to the method
       // where the call occurs.
       ReceiverT = cast<ObjCObjectPointerType>(SupersType);
     } else {
       Receiver = getReceiverSVal().getAsRegion();
       if (!Receiver)
         return {};
 
-      DynamicTypeInfo DTI = getDynamicTypeInfo(getState(), Receiver);
-      if (!DTI.isValid()) {
+      Optional<DynamicTypeInfo> DTI = getDynamicTypeInfo(getState(), Receiver);
+      if (!DTI) {
         assert(isa<AllocaRegion>(Receiver) &&
                "Unhandled untyped region class!");
         return {};
       }
 
-      QualType DynType = DTI.getType();
-      CanBeSubClassed = DTI.canBeASubClass();
+      QualType DynType = DTI->getType();
+      CanBeSubClassed = DTI->canBeASubClass();
       ReceiverT = dyn_cast<ObjCObjectPointerType>(DynType.getCanonicalType());
 
       if (ReceiverT && CanBeSubClassed)
         if (ObjCInterfaceDecl *IDecl = ReceiverT->getInterfaceDecl())
           if (!canBeOverridenInSubclass(IDecl, Sel))
             CanBeSubClassed = false;
     }
 

clang/lib/StaticAnalyzer/Core/DynamicType.cpp

 
 /// A map from symbols to cast informations.
 REGISTER_MAP_WITH_PROGRAMSTATE(DynamicCastMap, const clang::ento::MemRegion *,
                                CastSet)
 
 namespace clang {
 namespace ento {
 
-DynamicTypeInfo getDynamicTypeInfo(ProgramStateRef State, const MemRegion *MR) {
+Optional<DynamicTypeInfo> getDynamicTypeInfo(ProgramStateRef State,
+                                             const MemRegion *MR) {
   MR = MR->StripCasts();
 
   // Look up the dynamic type in the GDM.
   if (const DynamicTypeInfo *DTI = State->get<DynamicTypeMap>(MR))
     return *DTI;
 
   // Otherwise, fall back to what we know about the region.
   if (const auto *TR = dyn_cast<TypedRegion>(MR))
     return DynamicTypeInfo(TR->getLocationType(), /*CanBeSub=*/false);
 
   if (const auto *SR = dyn_cast<SymbolicRegion>(MR)) {
     SymbolRef Sym = SR->getSymbol();
     return DynamicTypeInfo(Sym->getType());
   }
 
-  return {};
+  return None;
 }
 
-const DynamicTypeInfo *getRawDynamicTypeInfo(ProgramStateRef State,
+Optional<DynamicTypeInfo> getStoredDynamicTypeInfo(ProgramStateRef State,
                                                    const MemRegion *MR) {
-  return State->get<DynamicTypeMap>(MR);
+  if (const DynamicTypeInfo *DTI = State->get<DynamicTypeMap>(MR))
+    return *DTI;
+
+  return None;
 }
 
-const DynamicCastInfo *getDynamicCastInfo(ProgramStateRef State,
+Optional<DynamicCastInfo> getDynamicCastInfo(ProgramStateRef State,
                                              const MemRegion *MR,
                                              QualType CastFromTy,
                                              QualType CastToTy) {
   const auto *Lookup = State->get<DynamicCastMap>().lookup(MR);
   if (!Lookup)
-    return nullptr;
+    return None;
 
   for (const DynamicCastInfo &Cast : *Lookup)
     if (Cast.equals(CastFromTy, CastToTy))
-      return &Cast;
+      return Cast;
 
-  return nullptr;
+  return None;
 }
 
 ProgramStateRef setDynamicTypeInfo(ProgramStateRef State, const MemRegion *MR,
                                    DynamicTypeInfo NewTy) {
   State = State->set<DynamicTypeMap>(MR->StripCasts(), NewTy);
   assert(State);
   return State;
 }
 
 ProgramStateRef setDynamicTypeInfo(ProgramStateRef State, const MemRegion *MR,
                                    QualType NewTy, bool CanBeSubClassed) {
   return setDynamicTypeInfo(State, MR, DynamicTypeInfo(NewTy, CanBeSubClassed));
 }
 
 ProgramStateRef setDynamicTypeAndCastInfo(ProgramStateRef State,
                                           const MemRegion *MR,
                                           QualType CastFromTy,
                                           QualType CastToTy,
                                           bool CastSucceeds) {
   if (!MR)
     return State;