refactor visitors to use common helper

Author: a-tarasyuk

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

@@ -499,9 +499,6 @@ class ExprEngine {
   void VisitGuardedExpr(const Expr *Ex, const Expr *L, const Expr *R,
                         ExplodedNode *Pred, ExplodedNodeSet &Dst);
 
-  void VisitInitListExpr(const InitListExpr *E, ExplodedNode *Pred,
-                         ExplodedNodeSet &Dst);
-
   /// VisitAttributedStmt - Transfer function logic for AttributedStmt.
   void VisitAttributedStmt(const AttributedStmt *A, ExplodedNode *Pred,
                            ExplodedNodeSet &Dst);
@@ -586,17 +583,14 @@ class ExprEngine {
   void VisitCXXDeleteExpr(const CXXDeleteExpr *CDE, ExplodedNode *Pred,
                           ExplodedNodeSet &Dst);
 
-  void VisitCXXParenListInitExpr(const CXXParenListInitExpr *PLIE,
-                                 ExplodedNode *Pred, ExplodedNodeSet &Dst);
-
   /// Create a C++ temporary object for an rvalue.
   void CreateCXXTemporaryObject(const MaterializeTemporaryExpr *ME,
                                 ExplodedNode *Pred,
                                 ExplodedNodeSet &Dst);
 
-  void CreateInitializationList(const Expr *Source, ArrayRef<Expr *> Args,
-                                bool IsTransparent, ExplodedNode *Pred,
-                                ExplodedNodeSet &Dst);
+  void ConstructInitList(const Expr *Source, ArrayRef<Expr *> Args,
+                         bool IsTransparent, ExplodedNode *Pred,
+                         ExplodedNodeSet &Dst);
 
   /// evalEagerlyAssumeBifurcation - Given the nodes in 'Src', eagerly assume
   /// concrete boolean values for 'Ex', storing the resulting nodes in 'Dst'.

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

@@ -2314,17 +2314,22 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
       break;
     }
 
-    case Stmt::InitListExprClass:
+    case Stmt::InitListExprClass: {
+      const InitListExpr *E = cast<InitListExpr>(S);
       Bldr.takeNodes(Pred);
-      VisitInitListExpr(cast<InitListExpr>(S), Pred, Dst);
+      ConstructInitList(E, E->inits(), E->isTransparent(), Pred, Dst);
       Bldr.addNodes(Dst);
       break;
+    }
 
-    case Expr::CXXParenListInitExprClass:
+    case Expr::CXXParenListInitExprClass: {
+      const CXXParenListInitExpr *E = cast<CXXParenListInitExpr>(S);
       Bldr.takeNodes(Pred);
-      VisitCXXParenListInitExpr(cast<CXXParenListInitExpr>(S), Pred, Dst);
+      ConstructInitList(E, E->getInitExprs(), /*IsTransparent*/ false, Pred,
+                        Dst);
       Bldr.addNodes(Dst);
       break;
+    }
 
     case Stmt::MemberExprClass:
       Bldr.takeNodes(Pred);
@@ -4119,3 +4124,35 @@ void *ProgramStateTrait<ReplayWithoutInlining>::GDMIndex() {
 }
 
 void ExprEngine::anchor() { }
+
+void ExprEngine::ConstructInitList(const Expr *E, ArrayRef<Expr *> Args,
+                                   bool IsTransparent, ExplodedNode *Pred,
+                                   ExplodedNodeSet &Dst) {
+  assert((isa<InitListExpr>(E) || isa<CXXParenListInitExpr>(E)) &&
+         "Expected InitListExpr or CXXParenListInitExpr");
+
+  const LocationContext *LC = Pred->getLocationContext();
+
+  StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
+  ProgramStateRef S = Pred->getState();
+  QualType T = E->getType().getCanonicalType();
+
+  bool IsCompound =
+      E->isPRValue() && (T->isArrayType() || T->isRecordType() ||
+                         T->isAnyComplexType() || T->isVectorType());
+
+  if (Args.size() > 1 || (IsCompound && !IsTransparent)) {
+    llvm::ImmutableList<SVal> ArgList = getBasicVals().getEmptySValList();
+    for (Expr *E : llvm::reverse(Args))
+      ArgList = getBasicVals().prependSVal(S->getSVal(E, LC), ArgList);
+
+    B.generateNode(E, Pred,
+                   S->BindExpr(E, LC, svalBuilder.makeCompoundVal(T, ArgList)));
+  } else {
+    B.generateNode(E, Pred,
+                   S->BindExpr(E, LC,
+                               Args.size() == 0
+                                   ? getSValBuilder().makeZeroVal(T)
+                                   : S->getSVal(Args.front(), LC)));
+  }
+}

clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp

@@ -771,12 +771,6 @@ void ExprEngine::VisitLogicalExpr(const BinaryOperator* B, ExplodedNode *Pred,
   Bldr.generateNode(B, Pred, state->BindExpr(B, Pred->getLocationContext(), X));
 }
 
-void ExprEngine::VisitInitListExpr(const InitListExpr *IE,
-                                   ExplodedNode *Pred,
-                                   ExplodedNodeSet &Dst) {
-  CreateInitializationList(IE, IE->inits(), IE->isTransparent(), Pred, Dst);
-}
-
 void ExprEngine::VisitGuardedExpr(const Expr *Ex,
                                   const Expr *L,
                                   const Expr *R,
@@ -1155,36 +1149,3 @@ void ExprEngine::VisitIncrementDecrementOperator(const UnaryOperator* U,
   }
   Dst.insert(Dst2);
 }
-
-void ExprEngine::CreateInitializationList(const Expr *E, ArrayRef<Expr *> Args,
-                                          bool IsTransparent,
-                                          ExplodedNode *Pred,
-                                          ExplodedNodeSet &Dst) {
-  assert((isa<InitListExpr>(E) || isa<CXXParenListInitExpr>(E)) &&
-         "Expected InitListExpr or CXXParenListInitExpr");
-
-  const LocationContext *LC = Pred->getLocationContext();
-
-  StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
-  ProgramStateRef S = Pred->getState();
-  QualType T = E->getType().getCanonicalType();
-
-  bool IsCompound =
-      E->isPRValue() && (T->isArrayType() || T->isRecordType() ||
-                         T->isAnyComplexType() || T->isVectorType());
-
-  if (Args.size() > 1 || (IsCompound && !IsTransparent)) {
-    llvm::ImmutableList<SVal> ArgList = getBasicVals().getEmptySValList();
-    for (Expr *E : llvm::reverse(Args))
-      ArgList = getBasicVals().prependSVal(S->getSVal(E, LC), ArgList);
-
-    B.generateNode(E, Pred,
-                   S->BindExpr(E, LC, svalBuilder.makeCompoundVal(T, ArgList)));
-  } else {
-    B.generateNode(E, Pred,
-                   S->BindExpr(E, LC,
-                               Args.size() == 0
-                                   ? getSValBuilder().makeZeroVal(T)
-                                   : S->getSVal(Args.front(), LC)));
-  }
-}

clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

@@ -1233,10 +1233,3 @@ void ExprEngine::VisitAttributedStmt(const AttributedStmt *A,
 
   getCheckerManager().runCheckersForPostStmt(Dst, EvalSet, A, *this);
 }
-
-void ExprEngine::VisitCXXParenListInitExpr(const CXXParenListInitExpr *E,
-                                           ExplodedNode *Pred,
-                                           ExplodedNodeSet &Dst) {
-  CreateInitializationList(E, E->getInitExprs(), /*IsTransparent*/ false, Pred,
-                           Dst);
-}