Simplify SymbolOverlyComplex creation by just wrapping the overly complicated symbol

Author: balazs-benics-sonarsource

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

@@ -138,92 +138,38 @@ class SymbolConjured : public SymbolData {
 };
 
 /// A symbol representing the result of an expression that became too
-/// complicated. In other words, its complexity would have surpassed the
+/// complicated. In other words, its complexity surpassed the
 /// MaxSymbolComplexity threshold.
 /// TODO: When the MaxSymbolComplexity is reached, we should propagate the taint
 /// info to it.
 class SymbolOverlyComplex final : public SymbolData {
-  // Pointer to either "SymExpr" or "APSInt".
-  const void *LHS;
-  const void *RHS = nullptr; // optional
-  QualType Ty;
-  using OpKindType = std::make_unsigned_t<
-      std::common_type_t<BinaryOperatorKind, UnaryOperatorKind>>;
-  OpKindType Op = 0;
+  const SymExpr *OverlyComplicatedSymbol;
 
   friend class SymExprAllocator;
 
-  static const void *getPointer(APSIntPtr Value) { return Value.get(); }
-  static const void *getPointer(const SymExpr *Value) { return Value; }
-
-  template <typename LHSTYPE, typename RHSTYPE>
-  using assertTypesForOperands = std::enable_if_t<
-      llvm::is_one_of<LHSTYPE, const SymExpr *, APSIntPtr>::value &&
-      llvm::is_one_of<RHSTYPE, const SymExpr *, APSIntPtr>::value>;
-
-  // Constructing from BinarySymExprImpl ctor arguments.
-  template <typename LHSTYPE, typename RHSTYPE,
-            typename = assertTypesForOperands<LHSTYPE, RHSTYPE>>
-  SymbolOverlyComplex(SymbolID Sym, LHSTYPE LHS, BinaryOperatorKind Op,
-                      RHSTYPE RHS, QualType Ty)
-      : SymbolData(ClassKind, Sym), LHS(getPointer(LHS)), RHS(getPointer(RHS)),
-        Ty(Ty), Op(static_cast<OpKindType>(Op)) {
-    assert(this->LHS);
-    assert(this->RHS);
-  }
-
-  // Constructing from UnarySymExpr ctor arguments.
-  SymbolOverlyComplex(SymbolID Sym, const SymExpr *Operand,
-                      UnaryOperatorKind Op, QualType Ty)
-      : SymbolData(ClassKind, Sym), LHS(Operand), Ty(Ty),
-        Op(static_cast<OpKindType>(Op)) {
-    assert(LHS);
-    assert(!RHS);
+  SymbolOverlyComplex(SymbolID Sym, const SymExpr *OverlyComplicatedSymbol)
+      : SymbolData(ClassKind, Sym),
+        OverlyComplicatedSymbol(OverlyComplicatedSymbol) {
+    assert(OverlyComplicatedSymbol);
   }
 
-  // Constructing from SymbolCast ctor arguments.
-  SymbolOverlyComplex(SymbolID Sym, const SymExpr *Operand, QualType,
-                      QualType ToTy)
-      : SymbolData(ClassKind, Sym), LHS(Operand), Ty(ToTy), Op(~0) {}
-
 public:
-  QualType getType() const override { return Ty; }
+  QualType getType() const override {
+    return OverlyComplicatedSymbol->getType();
+  }
 
   StringRef getKindStr() const override;
 
   void dumpToStream(raw_ostream &os) const override;
 
-  static void Profile(llvm::FoldingSetNodeID &profile, const void *LHS,
-                      OpKindType Op, const void *RHS, QualType Ty) {
+  static void Profile(llvm::FoldingSetNodeID &profile,
+                      const SymExpr *OverlyComplicatedSymbol) {
     profile.AddInteger((unsigned)ClassKind);
-    profile.AddPointer(LHS);
-    profile.AddPointer(RHS);
-    profile.Add(Ty);
-    profile.AddInteger(Op);
-  }
-
-  // Profile from BinarySymExprImpl ctor arguments.
-  template <typename LHSTYPE, typename RHSTYPE,
-            typename = assertTypesForOperands<LHSTYPE, RHSTYPE>>
-  static void Profile(llvm::FoldingSetNodeID &profile, LHSTYPE LHS,
-                      OpKindType Op, RHSTYPE RHS, QualType Ty) {
-    Profile(profile, getPointer(LHS), Op, getPointer(RHS), Ty);
-  }
-
-  // Profile from UnarySymExpr ctor arguments.
-  static void Profile(llvm::FoldingSetNodeID &profile, const SymExpr *Operand,
-                      UnaryOperatorKind Op, QualType Ty) {
-    Profile(profile, Operand, Op, /*RHS=*/nullptr, Ty);
-  }
-
-  // Profile from SymbolCast ctor arguments.
-  static void Profile(llvm::FoldingSetNodeID &profile, const SymExpr *Operand,
-                      QualType, QualType ToTy) {
-    Profile(profile, Operand, /*Op=*/~0, /*RHS=*/nullptr, ToTy);
+    profile.AddPointer(OverlyComplicatedSymbol);
   }
 
   void Profile(llvm::FoldingSetNodeID &profile) override {
-    Profile(profile, LHS, Op, RHS, Ty);
+    Profile(profile, OverlyComplicatedSymbol);
   }
 
   // Implement isa<T> support.
@@ -781,25 +727,19 @@ class SymbolVisitor {
   virtual bool VisitMemRegion(const MemRegion *) { return true; }
 };
 
-// Returns a pointer to T if T is a SymbolData, otherwise SymExpr.
+// Returns a const pointer to T if T is a SymbolData, otherwise SymExpr.
 template <typename T, typename... Args, typename Ret>
 const Ret *SymbolManager::acquire(Args &&...args) {
-  if constexpr (SymbolData::classof(T::ClassKind)) {
-    assert(T::computeComplexity(args...) == 1);
-  } else {
-    if (T::computeComplexity(args...) > MaxCompComplexity) {
-      return cast<Ret>(acquire<SymbolOverlyComplex>(args...));
-    }
-  }
-
   llvm::FoldingSetNodeID profile;
   T::Profile(profile, args...);
   void *InsertPos;
   SymExpr *SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
   if (!SD) {
     SD = Alloc.make<T>(std::forward<Args>(args)...);
     DataSet.InsertNode(SD, InsertPos);
-    assert(SD->complexity() <= MaxCompComplexity);
+    if (SD->complexity() > MaxCompComplexity) {
+      return cast<Ret>(acquire<SymbolOverlyComplex>(SD));
+    }
   }
 
   return cast<Ret>(SD);