[analyzer][NFC] Factor out the copy-paste code repetition of assumeDual and assumeInclusiveRangeDual

[martong]

Summary

Depends on D125892. There might be efficiency and performance
implications by using a lambda. Thus, I am going to conduct measurements
to see if there is any noticeable impact.
I've been thinking about two more alternatives:

1. Make assumeDualImpl a variadic template and (perfect) forward the arguments for the used assume function.
2. Use a macros.

I have concerns though, whether these alternatives would deteriorate the
readability of the code.

[steakhal]

Okay, it still looks a bit odd, but this is definitely an increment.

clang/lib/StaticAnalyzer/Core/ConstraintManager.cpp

48

Although this is a variable referring to a function, it's still a variable.
I find it difficult to read if a variable name is a verb.

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

protected:
   ///  reasonably handle a given SVal value.  This is typically queried by
   ///  ExprEngine to determine if the value should be replaced with a
   ///  conjured symbolic value in order to recover some precision.
   virtual bool canReasonAbout(SVal X) const = 0;
 
   /// Returns whether or not a symbol is known to be null ("true"), known to be
   /// non-null ("false"), or may be either ("underconstrained").
   virtual ConditionTruthVal checkNull(ProgramStateRef State, SymbolRef Sym);
+
+  template <typename AssumeFunction>
+  ProgramStatePair assumeDualImpl(ProgramStateRef &State,
+                                  AssumeFunction &Assume);
 };
 
 std::unique_ptr<ConstraintManager>
 CreateRangeConstraintManager(ProgramStateManager &statemgr,
                              ExprEngine *exprengine);
 
 std::unique_ptr<ConstraintManager>
 CreateZ3ConstraintManager(ProgramStateManager &statemgr,
                           ExprEngine *exprengine);
 
 } // namespace ento
 } // namespace clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CONSTRAINTMANAGER_H

clang/lib/StaticAnalyzer/Core/ConstraintManager.cpp

ConditionTruthVal ConstraintManager::checkNull(ProgramStateRef State,
   const ProgramStatePair &P = assumeDual(State, V);
   if (P.first && !P.second)
     return ConditionTruthVal(false);
   if (!P.first && P.second)
     return ConditionTruthVal(true);
   return {};
 }
 
+template <typename AssumeFunction>
 ConstraintManager::ProgramStatePair
-ConstraintManager::assumeDual(ProgramStateRef State, DefinedSVal Cond) {
-  ProgramStateRef StTrue = assumeInternal(State, Cond, true);
+ConstraintManager::assumeDualImpl(ProgramStateRef &State,
+                                  AssumeFunction &Assume) {
+  ProgramStateRef StTrue = Assume(true);
 
   if (!StTrue) {
-    ProgramStateRef StFalse = assumeInternal(State, Cond, false);
+    ProgramStateRef StFalse = Assume(false);
     if (LLVM_UNLIKELY(!StFalse)) { // both infeasible
       ProgramStateRef StInfeasible = State->cloneAsPosteriorlyOverconstrained();
       assert(StInfeasible->isPosteriorlyOverconstrained());
       // Checkers might rely on the API contract that both returned states
       // cannot be null. Thus, we return StInfeasible for both branches because
       // it might happen that a Checker uncoditionally uses one of them if the
       // other is a nullptr. This may also happen with the non-dual and
       // adjacent `assume(true)` and `assume(false)` calls. By implementing
       // assume in therms of assumeDual, we can keep our API contract there as
       // well.
       return ProgramStatePair(StInfeasible, StInfeasible);
     }
     return ProgramStatePair(nullptr, StFalse);
   }
 
-  ProgramStateRef StFalse = assumeInternal(State, Cond, false);
+  ProgramStateRef StFalse = Assume(false);
   if (!StFalse) {
     return ProgramStatePair(StTrue, nullptr);
   }
 
   return ProgramStatePair(StTrue, StFalse);
 }
 
 ConstraintManager::ProgramStatePair
+ConstraintManager::assumeDual(ProgramStateRef State, DefinedSVal Cond) {
+  auto AssumeFun = [&](bool Assumption) {
+    return assumeInternal(State, Cond, Assumption);
+  };
+  return assumeDualImpl(State, AssumeFun);
+}
+
+ConstraintManager::ProgramStatePair
 ConstraintManager::assumeInclusiveRangeDual(ProgramStateRef State, NonLoc Value,
                                             const llvm::APSInt &From,
                                             const llvm::APSInt &To) {
-  ProgramStateRef StInRange =
-      assumeInclusiveRangeInternal(State, Value, From, To, true);
-  if (!StInRange) {
-    ProgramStateRef StOutOfRange =
-        assumeInclusiveRangeInternal(State, Value, From, To, false);
-    if (LLVM_UNLIKELY(!StOutOfRange)) { // both infeasible
-      ProgramStateRef StInfeasible = State->cloneAsPosteriorlyOverconstrained();
-      assert(StInfeasible->isPosteriorlyOverconstrained());
-      // Checkers might rely on the API contract that both returned states
-      // cannot be null. Thus, we return StInfeasible for both branches because
-      // it might happen that a Checker uncoditionally uses one of them if the
-      // other is a nullptr. This may also happen with the non-dual and
-      // adjacent `assume(true)` and `assume(false)` calls. By implementing
-      // assume in therms of assumeDual, we can keep our API contract there as
-      // well.
-      return ProgramStatePair(StInfeasible, StInfeasible);
-    }
-  }
-
-  ProgramStateRef StOutOfRange =
-      assumeInclusiveRangeInternal(State, Value, From, To, false);
-  if (!StOutOfRange) {
-    return ProgramStatePair(StInRange, nullptr);
-  }
-
-  return ProgramStatePair(StInRange, StOutOfRange);
+  auto AssumeFun = [&](bool Assumption) {
+    return assumeInclusiveRangeInternal(State, Value, From, To, Assumption);
+  };
+  return assumeDualImpl(State, AssumeFun);
 }
 
 ProgramStateRef ConstraintManager::assume(ProgramStateRef State,
                                           DefinedSVal Cond, bool Assumption) {
   ConstraintManager::ProgramStatePair R = assumeDual(State, Cond);
   return Assumption ? R.first : R.second;
 }
 
 ProgramStateRef
 ConstraintManager::assumeInclusiveRange(ProgramStateRef State, NonLoc Value,
                                         const llvm::APSInt &From,
                                         const llvm::APSInt &To, bool InBound) {
   ConstraintManager::ProgramStatePair R =
       assumeInclusiveRangeDual(State, Value, From, To);
   return InBound ? R.first : R.second;
 }