[analyzer][NFC] Inline and simplify nonloc::ConcreteInt functions

[martong]

clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp

90

I'd rather keep the switch because in D125318 we are going to extend with nonloc::SymbolValKind so, soon it will no longer be a standalone case.

[steakhal]

clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp

90

Okay, let's postpone this until things get settled with the unary ops stuff.

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

public:
   const llvm::APSInt& getValue() const {
     return *static_cast<const llvm::APSInt *>(Data);
   }
 
   // Transfer functions for binary/unary operations on ConcreteInts.
   SVal evalBinOp(SValBuilder &svalBuilder, BinaryOperator::Opcode Op,
                  const ConcreteInt& R) const;
 
-  ConcreteInt evalComplement(SValBuilder &svalBuilder) const;
-
-  ConcreteInt evalMinus(SValBuilder &svalBuilder) const;
-
 private:
   friend class SVal;
 
   ConcreteInt() = default;
 
   static bool isKind(const SVal& V) {
     return V.getBaseKind() == NonLocKind &&
            V.getSubKind() == ConcreteIntKind;

clang/lib/StaticAnalyzer/Core/SVals.cpp

const llvm::APSInt* X =
     svalBuilder.getBasicValueFactory().evalAPSInt(Op, getValue(), R.getValue());
 
   if (X)
     return nonloc::ConcreteInt(*X);
   else
     return UndefinedVal();
 }
 
-nonloc::ConcreteInt
-nonloc::ConcreteInt::evalComplement(SValBuilder &svalBuilder) const {
-  return svalBuilder.makeIntVal(~getValue());
-}
-
-nonloc::ConcreteInt
-nonloc::ConcreteInt::evalMinus(SValBuilder &svalBuilder) const {
-  return svalBuilder.makeIntVal(-getValue());
-}
-
 //===----------------------------------------------------------------------===//
 // Transfer function dispatch for Locs.
 //===----------------------------------------------------------------------===//
 
 SVal loc::ConcreteInt::evalBinOp(BasicValueFactory& BasicVals,
                                  BinaryOperator::Opcode Op,
                                  const loc::ConcreteInt& R) const {
   assert(BinaryOperator::isComparisonOp(Op) || Op == BO_Sub);

clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp

SValBuilder *ento::createSimpleSValBuilder(llvm::BumpPtrAllocator &alloc,
                                            ProgramStateManager &stateMgr) {
   return new SimpleSValBuilder(alloc, context, stateMgr);
 }
 
 //===----------------------------------------------------------------------===//
 // Transfer function for unary operators.
 //===----------------------------------------------------------------------===//
 
-SVal SimpleSValBuilder::evalMinus(NonLoc val) {
-  switch (val.getSubKind()) {
-  case nonloc::ConcreteIntKind:
-    return val.castAs<nonloc::ConcreteInt>().evalMinus(*this);
-  default:
-    return UnknownVal();
-  }
-}
+SVal SimpleSValBuilder::evalMinus(NonLoc V) {
+  if (auto C = V.getAs<nonloc::ConcreteInt>())
+    return makeIntVal(-C->getValue());
 
-SVal SimpleSValBuilder::evalComplement(NonLoc X) {
-  switch (X.getSubKind()) {
-  case nonloc::ConcreteIntKind:
-    return X.castAs<nonloc::ConcreteInt>().evalComplement(*this);
-  default:
-    return UnknownVal();
-  }
-}
+SVal SimpleSValBuilder::evalComplement(NonLoc V) {
+  if (auto C = V.getAs<nonloc::ConcreteInt>())
+    return makeIntVal(~C->getValue());
 
 // Checks if the negation the value and flipping sign preserve
 // the semantics on the operation in the resultType
 static bool isNegationValuePreserving(const llvm::APSInt &Value,
                                       APSIntType ResultType) {
   const unsigned ValueBits = Value.getSignificantBits();
   if (ValueBits == ResultType.getBitWidth()) {
     // The value is the lowest negative value that is representable