Move functions into CallEvent class

Author: Gabor Spaits

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

@@ -455,6 +455,14 @@ class CallEvent {
   /// If the call returns a C++ record type then the region of its return value
   /// can be retrieved from its construction context.
   std::optional<SVal> getReturnValueUnderConstruction() const;
+  
+  // Returns the CallEvent representing the caller of this function
+  const CallEventRef<> getCaller() const;
+
+  // Returns true if the function was called from a standard library function.
+  // If not or could not get the caller (it may be a top level function)
+  // returns false.
+  bool calledFromSystemHeader() const;
 
   // Iterator access to formal parameters and their types.
 private:

clang/lib/StaticAnalyzer/Checkers/StdVariantChecker.cpp

@@ -29,22 +29,7 @@ using namespace tagged_union_modeling;
 
 REGISTER_MAP_WITH_PROGRAMSTATE(VariantHeldTypeMap, const MemRegion *, QualType)
 
-namespace clang {
-namespace ento {
-namespace tagged_union_modeling {
-
-CallEventRef<> getCaller(const CallEvent &Call, const ProgramStateRef &State) {
-  const auto *CallLocationContext = Call.getLocationContext();
-  if (!CallLocationContext || CallLocationContext->inTopFrame())
-    return nullptr;
-
-  const auto *CallStackFrameContext = CallLocationContext->getStackFrame();
-  if (!CallStackFrameContext)
-    return nullptr;
-
-  CallEventManager &CEMgr = State->getStateManager().getCallEventManager();
-  return CEMgr.getCaller(CallStackFrameContext, State);
-}
+namespace clang::ento::tagged_union_modeling {
 
 const CXXConstructorDecl *
 getConstructorDeclarationForCall(const CallEvent &Call) {
@@ -102,21 +87,7 @@ bool isStdVariant(const Type *Type) {
   return isStdType(Type, llvm::StringLiteral("variant"));
 }
 
-bool calledFromSystemHeader(const CallEvent &Call,
-                            const ProgramStateRef &State) {
-  if (CallEventRef<> Caller = getCaller(Call, State))
-    return Caller->isInSystemHeader();
-
-  return false;
-}
-
-bool calledFromSystemHeader(const CallEvent &Call, CheckerContext &C) {
-  return calledFromSystemHeader(Call, C.getState());
-}
-
-} // end of namespace tagged_union_modeling
-} // end of namespace ento
-} // end of namespace clang
+} // end of namespace clang::ento::tagged_union_modeling
 
 static std::optional<ArrayRef<TemplateArgument>>
 getTemplateArgsFromVariant(const Type *VariantType) {
@@ -171,14 +142,17 @@ class StdVariantChecker : public Checker<eval::Call, check::RegionChanges> {
                                      ArrayRef<const MemRegion *> Regions,
                                      const LocationContext *,
                                      const CallEvent *Call) const {
+    if (!Call)
+      return State;
+
     return removeInformationStoredForDeadInstances<VariantHeldTypeMap>(
-        Call, State, Regions);
+        *Call, State, Regions);
   }
 
   bool evalCall(const CallEvent &Call, CheckerContext &C) const {
     // Check if the call was not made from a system header. If it was then
     // we do an early return because it is part of the implementation.
-    if (calledFromSystemHeader(Call, C))
+    if (Call.calledFromSystemHeader())
       return false;
 
     if (StdGet.matches(Call))

clang/lib/StaticAnalyzer/Checkers/TaggedUnionModeling.h

@@ -24,29 +24,24 @@ namespace clang::ento::tagged_union_modeling {
 // The implementation of all these functions can be found in the file
 // StdVariantChecker.cpp under the same directory as this file.
 
-// Returns the CallEvent representing the caller of the function
-// It is needed because the CallEvent class does not contain enough information
-// to tell who called it. Checker context is needed.
-CallEventRef<> getCaller(const CallEvent &Call, CheckerContext &C);
 bool isCopyConstructorCall(const CallEvent &Call);
 bool isCopyAssignmentCall(const CallEvent &Call);
 bool isMoveAssignmentCall(const CallEvent &Call);
 bool isMoveConstructorCall(const CallEvent &Call);
 bool isStdType(const Type *Type, const std::string &TypeName);
 bool isStdVariant(const Type *Type);
-bool calledFromSystemHeader(const CallEvent &Call, CheckerContext &C);
 
 // When invalidating regions, we also have to follow that by invalidating the
 // corresponding custom data in the program state.
 template <class TypeMap>
 ProgramStateRef
-removeInformationStoredForDeadInstances(const CallEvent *Call,
+removeInformationStoredForDeadInstances(const CallEvent &Call,
                                         ProgramStateRef State,
                                         ArrayRef<const MemRegion *> Regions) {
   // If we do not know anything about the call we shall not continue.
   // If the call is happens within a system header it is implementation detail.
   // We should not take it into consideration.
-  if (!Call || Call->isInSystemHeader())
+  if (Call.isInSystemHeader())
     return State;
 
   for (const MemRegion *Region : Regions)

clang/lib/StaticAnalyzer/Core/CallEvent.cpp

@@ -517,6 +517,26 @@ const ConstructionContext *CallEvent::getConstructionContext() const {
   return nullptr;
 }
 
+const CallEventRef<> CallEvent::getCaller() const {
+  const auto *CallLocationContext = this->getLocationContext();
+  if (!CallLocationContext || CallLocationContext->inTopFrame())
+    return nullptr;
+
+  const auto *CallStackFrameContext = CallLocationContext->getStackFrame();
+  if (!CallStackFrameContext)
+    return nullptr;
+
+  CallEventManager &CEMgr = State->getStateManager().getCallEventManager();
+  return CEMgr.getCaller(CallStackFrameContext, State);
+}
+
+bool CallEvent::calledFromSystemHeader() const {
+  if (const CallEventRef<> Caller = getCaller())
+    return Caller->isInSystemHeader();
+
+  return false;
+}
+
 std::optional<SVal> CallEvent::getReturnValueUnderConstruction() const {
   const auto *CC = getConstructionContext();
   if (!CC)